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 |
|---|---|---|---|---|
domain_randomization.py | to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL FABIO MURATORE, HONDA RESEARCH INSTITUTE EUROPE GMBH,
# OR TECHNICAL UNIVERSITY OF DARMSTADT BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
from random import randint
from typing import List, Mapping, Optional, Tuple, Union
import numpy as np
from init_args_serializer import Serializable
import pyrado
from pyrado.domain_randomization.domain_randomizer import DomainRandomizer
from pyrado.environment_wrappers.base import EnvWrapper
from pyrado.environment_wrappers.utils import all_envs, inner_env, remove_env
from pyrado.environments.base import Env
from pyrado.environments.sim_base import SimEnv
from pyrado.utils.input_output import completion_context, print_cbt
class DomainRandWrapper(EnvWrapper, Serializable):
"""Base class for environment wrappers which call a `DomainRandomizer` to randomize the domain parameters"""
def __init__(self, wrapped_env: Union[SimEnv, EnvWrapper], randomizer: Optional[DomainRandomizer]):
"""
Constructor
:param wrapped_env: environment to wrap
:param randomizer: `DomainRandomizer` object holding the probability distribution of all randomizable
domain parameters, pass `None` if you want to subclass wrapping another `DomainRandWrapper`
and use its randomizer
"""
if not isinstance(inner_env(wrapped_env), SimEnv):
raise pyrado.TypeErr(given=wrapped_env, expected_type=SimEnv)
if not isinstance(randomizer, DomainRandomizer) and randomizer is not None:
raise pyrado.TypeErr(given=randomizer, expected_type=DomainRandomizer)
Serializable._init(self, locals())
# Invoke EnvWrapper's constructor
super().__init__(wrapped_env)
self._randomizer = randomizer
@property
def randomizer(self) -> DomainRandomizer:
return self._randomizer
@randomizer.setter
def randomizer(self, randomizer: DomainRandomizer):
if not isinstance(randomizer, DomainRandomizer):
raise pyrado.TypeErr(given=randomizer, expected_type=DomainRandomizer)
self._randomizer = randomizer
class MetaDomainRandWrapper(DomainRandWrapper, Serializable):
"""
Domain randomization wrapper which wraps another `DomainRandWrapper` to adapt its parameters,
called domain distribution parameters.
"""
def __init__(self, wrapped_rand_env: DomainRandWrapper, dp_mapping: Mapping[int, Tuple[str, str]]):
"""
Constructor
:param wrapped_rand_env: randomized environment to wrap
:param dp_mapping: mapping from index of the numpy array (coming from the algorithm) to domain parameter name
(e.g. mass, length) and the domain distribution parameter (e.g. mean, std)
.. code-block:: python
# For the mapping arg use the this dict constructor
```
m = {0: ('name1', 'parameter_type1'), 1: ('name2', 'parameter_type2')}
```
"""
if not isinstance(wrapped_rand_env, DomainRandWrapper):
raise pyrado.TypeErr(given=wrapped_rand_env, expected_type=DomainRandWrapper)
Serializable._init(self, locals())
# Invoke the DomainRandWrapper's constructor
super().__init__(wrapped_rand_env, None)
self.dp_mapping = dp_mapping
@property
def randomizer(self) -> DomainRandomizer:
# Forward to the wrapped DomainRandWrapper
return self._wrapped_env.randomizer
@randomizer.setter
def randomizer(self, dr: DomainRandomizer):
# Forward to the wrapped DomainRandWrapper
self._wrapped_env.randomizer = dr
def adapt_randomizer(self, domain_distr_param_values: np.ndarray):
# Check the input dimension and reshape if necessary
if domain_distr_param_values.ndim == 1:
pass
elif domain_distr_param_values.ndim == 2:
domain_distr_param_values = domain_distr_param_values.ravel()
else:
raise pyrado.ShapeErr(given=domain_distr_param_values, expected_match=(1,))
# Reconfigure the wrapped environment's DomainRandomizer
for i, value in enumerate(domain_distr_param_values):
dp_name, ddp_name = self.dp_mapping.get(i)
self._wrapped_env.randomizer.adapt_one_distr_param(dp_name, ddp_name, value)
class DomainRandWrapperLive(DomainRandWrapper, Serializable):
"""
Domain randomization wrapper which randomized the wrapped env at every reset.
Thus every rollout is done with different domain parameters.
"""
def reset(self, init_state: np.ndarray = None, domain_param: dict = None) -> np.ndarray:
if domain_param is None:
# No explicit specification of domain parameters, so randomizer is called to draw a parameter dict
self._randomizer.randomize(num_samples=1)
domain_param = self._randomizer.get_params(fmt="dict", dtype="numpy")
# Forward to EnvWrapper, which delegates to self._wrapped_env
return super().reset(init_state=init_state, domain_param=domain_param)
class DomainRandWrapperBuffer(DomainRandWrapper, Serializable):
"""
Domain randomization wrapper which randomized the wrapped env using a buffer of domain parameter sets.
At every call of the reset method this wrapper cycles through that buffer.
"""
def __init__(self, wrapped_env, randomizer: Optional[DomainRandomizer], selection: Optional[str] = "cyclic"):
"""
Constructor
:param wrapped_env: environment to wrap around
:param randomizer: `DomainRandomizer` object that manages the randomization. If `None`, the user has to set the
buffer manually, the circular reset however works the same way
:param selection: method to draw samples from the buffer, either cyclic or random
"""
if selection not in ["cyclic", "random"]:
raise pyrado.ValueErr(given=selection, eq_constraint="cyclic or random")
Serializable._init(self, locals())
# Invoke the DomainRandWrapper's constructor
super().__init__(wrapped_env, randomizer)
self._ring_idx = None
self._buffer = None
self.selection = selection
@property
def ring_idx(self) -> int:
"""Get the buffer's index."""
return self._ring_idx
@ring_idx.setter
def ring_idx(self, idx: int):
"""Set the buffer's index."""
if not (isinstance(idx, int) or not 0 <= idx < len(self._buffer)):
raise pyrado.ValueErr(given=idx, ge_constraint="0 (int)", l_constraint=len(self._buffer))
self._ring_idx = idx
@property
def selection(self) -> str:
"""Get the selection method."""
return self._selection
@selection.setter
def selection(self, selection: str):
|
def fill_buffer(self, num_domains: int):
"""
Fill the internal buffer with domains.
:param num_domains: number of randomized domain parameter sets to store in the buffer
"""
if self._randomizer is None:
raise pyrado.TypeErr(msg="The randomizer must not be None to call fill_buffer()!")
if not isinstance(num_domains, int) or num_domains < 0:
raise pyrado.ValueErr(given=num_domains, g_constraint="0 (int)")
self._randomizer.randomize(num_domains)
self._buffer = self._randomizer.get_params(-1, fmt="list", dtype="numpy")
self._ring_idx = 0
@property
def buffer(self):
"""Get the domain parameter buffer."""
return self._buffer
@buffer.setter
def buffer(self, buffer: Union[List[dict], dict]):
"""
Set the domain parameter buffer.
Depends on the way the buffer has been saved, see the `DomainRandomizer.get_params()` arguments.
:param buffer: list of dicts, each describing a domain ,or just one dict for one domain
"""
if not (isinstance(buffer, list) or isinstance(buffer, dict)):
raise pyrado.TypeErr(given=buffer, expected_type=[list, dict])
self._buffer = buffer
def reset(self, init_state: np.ndarray = None, domain_param: dict = None) -> np.ndarray:
if domain_param is None:
# No explicit specification of domain parameters, so randomizer is requested
if isinstance(self._buffer, dict):
# The buffer consists of one domain parameter set
domain_param = self._buffer
elif isinstance(self._buffer, list):
# The buffer | """Set the selection method."""
if selection not in ["cyclic", "random"]:
raise pyrado.ValueErr(given=selection, eq_constraint="cyclic or random")
self._selection = selection | identifier_body |
borrow_set.rs | statement in which it appears on
/// the right hand side; we map each such location to the
/// corresponding `BorrowIndex`.
crate location_map: FxHashMap<Location, BorrowIndex>,
/// Locations which activate borrows.
/// NOTE: a given location may activate more than one borrow in the future
/// when more general two-phase borrow support is introduced, but for now we
/// only need to store one borrow index.
crate activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
/// Map from local to all the borrows on that local.
crate local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
crate locals_state_at_exit: LocalsStateAtExit,
}
impl<'tcx> Index<BorrowIndex> for BorrowSet<'tcx> {
type Output = BorrowData<'tcx>;
fn index(&self, index: BorrowIndex) -> &BorrowData<'tcx> {
&self.borrows[index]
}
}
/// Location where a two-phase borrow is activated, if a borrow
/// is in fact a two-phase borrow.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
crate enum TwoPhaseActivation {
NotTwoPhase,
NotActivated,
ActivatedAt(Location),
}
#[derive(Debug, Clone)]
crate struct BorrowData<'tcx> {
/// Location where the borrow reservation starts.
/// In many cases, this will be equal to the activation location but not always.
crate reserve_location: Location,
/// Location where the borrow is activated.
crate activation_location: TwoPhaseActivation,
/// What kind of borrow this is
crate kind: mir::BorrowKind,
/// The region for which this borrow is live
crate region: RegionVid,
/// Place from which we are borrowing
crate borrowed_place: mir::Place<'tcx>,
/// Place to which the borrow was stored
crate assigned_place: mir::Place<'tcx>,
}
impl<'tcx> fmt::Display for BorrowData<'tcx> {
fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
let kind = match self.kind {
mir::BorrowKind::Shared => "",
mir::BorrowKind::Shallow => "shallow ",
mir::BorrowKind::Unique => "uniq ",
mir::BorrowKind::Mut { .. } => "mut ",
};
write!(w, "&{:?} {}{:?}", self.region, kind, self.borrowed_place)
}
}
crate enum LocalsStateAtExit {
AllAreInvalidated,
SomeAreInvalidated { has_storage_dead_or_moved: BitSet<Local> }
}
impl LocalsStateAtExit {
fn | (
locals_are_invalidated_at_exit: bool,
body: &Body<'tcx>,
move_data: &MoveData<'tcx>
) -> Self {
struct HasStorageDead(BitSet<Local>);
impl<'tcx> Visitor<'tcx> for HasStorageDead {
fn visit_local(&mut self, local: &Local, ctx: PlaceContext, _: Location) {
if ctx == PlaceContext::NonUse(NonUseContext::StorageDead) {
self.0.insert(*local);
}
}
}
if locals_are_invalidated_at_exit {
LocalsStateAtExit::AllAreInvalidated
} else {
let mut has_storage_dead = HasStorageDead(BitSet::new_empty(body.local_decls.len()));
has_storage_dead.visit_body(body);
let mut has_storage_dead_or_moved = has_storage_dead.0;
for move_out in &move_data.moves {
if let Some(index) = move_data.base_local(move_out.path) {
has_storage_dead_or_moved.insert(index);
}
}
LocalsStateAtExit::SomeAreInvalidated{ has_storage_dead_or_moved }
}
}
}
impl<'tcx> BorrowSet<'tcx> {
pub fn build(
tcx: TyCtxt<'tcx>,
body: &Body<'tcx>,
locals_are_invalidated_at_exit: bool,
move_data: &MoveData<'tcx>,
) -> Self {
let mut visitor = GatherBorrows {
tcx,
body,
idx_vec: IndexVec::new(),
location_map: Default::default(),
activation_map: Default::default(),
local_map: Default::default(),
pending_activations: Default::default(),
locals_state_at_exit:
LocalsStateAtExit::build(locals_are_invalidated_at_exit, body, move_data),
};
for (block, block_data) in traversal::preorder(body) {
visitor.visit_basic_block_data(block, block_data);
}
BorrowSet {
borrows: visitor.idx_vec,
location_map: visitor.location_map,
activation_map: visitor.activation_map,
local_map: visitor.local_map,
locals_state_at_exit: visitor.locals_state_at_exit,
}
}
crate fn activations_at_location(&self, location: Location) -> &[BorrowIndex] {
self.activation_map
.get(&location)
.map(|activations| &activations[..])
.unwrap_or(&[])
}
}
struct GatherBorrows<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
body: &'a Body<'tcx>,
idx_vec: IndexVec<BorrowIndex, BorrowData<'tcx>>,
location_map: FxHashMap<Location, BorrowIndex>,
activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
/// When we encounter a 2-phase borrow statement, it will always
/// be assigning into a temporary TEMP:
///
/// TEMP = &foo
///
/// We add TEMP into this map with `b`, where `b` is the index of
/// the borrow. When we find a later use of this activation, we
/// remove from the map (and add to the "tombstone" set below).
pending_activations: FxHashMap<mir::Local, BorrowIndex>,
locals_state_at_exit: LocalsStateAtExit,
}
impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
fn visit_assign(
&mut self,
assigned_place: &mir::Place<'tcx>,
rvalue: &mir::Rvalue<'tcx>,
location: mir::Location,
) {
if let mir::Rvalue::Ref(region, kind, ref borrowed_place) = *rvalue {
if borrowed_place.ignore_borrow(
self.tcx, self.body, &self.locals_state_at_exit) {
return;
}
let region = region.to_region_vid();
let borrow = BorrowData {
kind,
region,
reserve_location: location,
activation_location: TwoPhaseActivation::NotTwoPhase,
borrowed_place: borrowed_place.clone(),
assigned_place: assigned_place.clone(),
};
let idx = self.idx_vec.push(borrow);
self.location_map.insert(location, idx);
self.insert_as_pending_if_two_phase(location, &assigned_place, kind, idx);
if let mir::PlaceBase::Local(local) = borrowed_place.base {
self.local_map.entry(local).or_default().insert(idx);
}
}
self.super_assign(assigned_place, rvalue, location)
}
fn visit_local(
&mut self,
temp: &Local,
context: PlaceContext,
location: Location,
) {
if !context.is_use() {
return;
}
// We found a use of some temporary TMP
// check whether we (earlier) saw a 2-phase borrow like
//
// TMP = &mut place
if let Some(&borrow_index) = self.pending_activations.get(temp) {
let borrow_data = &mut self.idx_vec[borrow_index];
// Watch out: the use of TMP in the borrow itself
// doesn't count as an activation. =)
if borrow_data.reserve_location == location &&
context == PlaceContext::MutatingUse(MutatingUseContext::Store)
{
return;
}
if let TwoPhaseActivation::ActivatedAt(other_location) =
borrow_data.activation_location {
span_bug!(
self.body.source_info(location).span,
"found two uses for 2-phase borrow temporary {:?}: \
{:?} and {:?}",
temp,
location,
other_location,
);
}
// Otherwise, this is the unique later use that we expect.
// Double check: This borrow is indeed a two-phase borrow (that is,
// we are 'transitioning' from `NotActivated` to `ActivatedAt`) and
// we've not found any other activations (checked above).
assert_eq!(
borrow_data.activation_location,
TwoPhaseActivation::NotActivated,
"never found an activation for this borrow!",
);
self.activation_map
.entry(location)
.or_default()
.push(borrow_index);
borrow_data.activation_location = TwoPhaseActivation::ActivatedAt(location);
}
}
fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: mir::Location) {
if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue {
// double-check that we already registered a | build | identifier_name |
borrow_set.rs | in which it appears on
/// the right hand side; we map each such location to the
/// corresponding `BorrowIndex`.
crate location_map: FxHashMap<Location, BorrowIndex>,
/// Locations which activate borrows.
/// NOTE: a given location may activate more than one borrow in the future
/// when more general two-phase borrow support is introduced, but for now we
/// only need to store one borrow index.
crate activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
/// Map from local to all the borrows on that local.
crate local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
crate locals_state_at_exit: LocalsStateAtExit,
}
impl<'tcx> Index<BorrowIndex> for BorrowSet<'tcx> {
type Output = BorrowData<'tcx>;
fn index(&self, index: BorrowIndex) -> &BorrowData<'tcx> {
&self.borrows[index]
}
}
/// Location where a two-phase borrow is activated, if a borrow
/// is in fact a two-phase borrow.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
crate enum TwoPhaseActivation {
NotTwoPhase,
NotActivated,
ActivatedAt(Location),
}
#[derive(Debug, Clone)]
crate struct BorrowData<'tcx> {
/// Location where the borrow reservation starts.
/// In many cases, this will be equal to the activation location but not always.
crate reserve_location: Location,
/// Location where the borrow is activated.
crate activation_location: TwoPhaseActivation,
/// What kind of borrow this is
crate kind: mir::BorrowKind,
/// The region for which this borrow is live
crate region: RegionVid,
/// Place from which we are borrowing
crate borrowed_place: mir::Place<'tcx>,
/// Place to which the borrow was stored
crate assigned_place: mir::Place<'tcx>,
}
impl<'tcx> fmt::Display for BorrowData<'tcx> {
fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
let kind = match self.kind {
mir::BorrowKind::Shared => "",
mir::BorrowKind::Shallow => "shallow ",
mir::BorrowKind::Unique => "uniq ",
mir::BorrowKind::Mut { .. } => "mut ",
};
write!(w, "&{:?} {}{:?}", self.region, kind, self.borrowed_place)
}
}
crate enum LocalsStateAtExit {
AllAreInvalidated,
SomeAreInvalidated { has_storage_dead_or_moved: BitSet<Local> }
}
impl LocalsStateAtExit {
fn build(
locals_are_invalidated_at_exit: bool,
body: &Body<'tcx>,
move_data: &MoveData<'tcx>
) -> Self {
struct HasStorageDead(BitSet<Local>);
impl<'tcx> Visitor<'tcx> for HasStorageDead {
fn visit_local(&mut self, local: &Local, ctx: PlaceContext, _: Location) {
if ctx == PlaceContext::NonUse(NonUseContext::StorageDead) |
}
}
if locals_are_invalidated_at_exit {
LocalsStateAtExit::AllAreInvalidated
} else {
let mut has_storage_dead = HasStorageDead(BitSet::new_empty(body.local_decls.len()));
has_storage_dead.visit_body(body);
let mut has_storage_dead_or_moved = has_storage_dead.0;
for move_out in &move_data.moves {
if let Some(index) = move_data.base_local(move_out.path) {
has_storage_dead_or_moved.insert(index);
}
}
LocalsStateAtExit::SomeAreInvalidated{ has_storage_dead_or_moved }
}
}
}
impl<'tcx> BorrowSet<'tcx> {
pub fn build(
tcx: TyCtxt<'tcx>,
body: &Body<'tcx>,
locals_are_invalidated_at_exit: bool,
move_data: &MoveData<'tcx>,
) -> Self {
let mut visitor = GatherBorrows {
tcx,
body,
idx_vec: IndexVec::new(),
location_map: Default::default(),
activation_map: Default::default(),
local_map: Default::default(),
pending_activations: Default::default(),
locals_state_at_exit:
LocalsStateAtExit::build(locals_are_invalidated_at_exit, body, move_data),
};
for (block, block_data) in traversal::preorder(body) {
visitor.visit_basic_block_data(block, block_data);
}
BorrowSet {
borrows: visitor.idx_vec,
location_map: visitor.location_map,
activation_map: visitor.activation_map,
local_map: visitor.local_map,
locals_state_at_exit: visitor.locals_state_at_exit,
}
}
crate fn activations_at_location(&self, location: Location) -> &[BorrowIndex] {
self.activation_map
.get(&location)
.map(|activations| &activations[..])
.unwrap_or(&[])
}
}
struct GatherBorrows<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
body: &'a Body<'tcx>,
idx_vec: IndexVec<BorrowIndex, BorrowData<'tcx>>,
location_map: FxHashMap<Location, BorrowIndex>,
activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
/// When we encounter a 2-phase borrow statement, it will always
/// be assigning into a temporary TEMP:
///
/// TEMP = &foo
///
/// We add TEMP into this map with `b`, where `b` is the index of
/// the borrow. When we find a later use of this activation, we
/// remove from the map (and add to the "tombstone" set below).
pending_activations: FxHashMap<mir::Local, BorrowIndex>,
locals_state_at_exit: LocalsStateAtExit,
}
impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
fn visit_assign(
&mut self,
assigned_place: &mir::Place<'tcx>,
rvalue: &mir::Rvalue<'tcx>,
location: mir::Location,
) {
if let mir::Rvalue::Ref(region, kind, ref borrowed_place) = *rvalue {
if borrowed_place.ignore_borrow(
self.tcx, self.body, &self.locals_state_at_exit) {
return;
}
let region = region.to_region_vid();
let borrow = BorrowData {
kind,
region,
reserve_location: location,
activation_location: TwoPhaseActivation::NotTwoPhase,
borrowed_place: borrowed_place.clone(),
assigned_place: assigned_place.clone(),
};
let idx = self.idx_vec.push(borrow);
self.location_map.insert(location, idx);
self.insert_as_pending_if_two_phase(location, &assigned_place, kind, idx);
if let mir::PlaceBase::Local(local) = borrowed_place.base {
self.local_map.entry(local).or_default().insert(idx);
}
}
self.super_assign(assigned_place, rvalue, location)
}
fn visit_local(
&mut self,
temp: &Local,
context: PlaceContext,
location: Location,
) {
if !context.is_use() {
return;
}
// We found a use of some temporary TMP
// check whether we (earlier) saw a 2-phase borrow like
//
// TMP = &mut place
if let Some(&borrow_index) = self.pending_activations.get(temp) {
let borrow_data = &mut self.idx_vec[borrow_index];
// Watch out: the use of TMP in the borrow itself
// doesn't count as an activation. =)
if borrow_data.reserve_location == location &&
context == PlaceContext::MutatingUse(MutatingUseContext::Store)
{
return;
}
if let TwoPhaseActivation::ActivatedAt(other_location) =
borrow_data.activation_location {
span_bug!(
self.body.source_info(location).span,
"found two uses for 2-phase borrow temporary {:?}: \
{:?} and {:?}",
temp,
location,
other_location,
);
}
// Otherwise, this is the unique later use that we expect.
// Double check: This borrow is indeed a two-phase borrow (that is,
// we are 'transitioning' from `NotActivated` to `ActivatedAt`) and
// we've not found any other activations (checked above).
assert_eq!(
borrow_data.activation_location,
TwoPhaseActivation::NotActivated,
"never found an activation for this borrow!",
);
self.activation_map
.entry(location)
.or_default()
.push(borrow_index);
borrow_data.activation_location = TwoPhaseActivation::ActivatedAt(location);
}
}
fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: mir::Location) {
if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue {
// double-check that we already registered a | {
self.0.insert(*local);
} | conditional_block |
borrow_set.rs | statement in which it appears on
/// the right hand side; we map each such location to the
/// corresponding `BorrowIndex`.
crate location_map: FxHashMap<Location, BorrowIndex>,
/// Locations which activate borrows.
/// NOTE: a given location may activate more than one borrow in the future
/// when more general two-phase borrow support is introduced, but for now we
/// only need to store one borrow index.
crate activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
/// Map from local to all the borrows on that local.
crate local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
crate locals_state_at_exit: LocalsStateAtExit,
}
impl<'tcx> Index<BorrowIndex> for BorrowSet<'tcx> {
type Output = BorrowData<'tcx>;
fn index(&self, index: BorrowIndex) -> &BorrowData<'tcx> {
&self.borrows[index]
}
}
/// Location where a two-phase borrow is activated, if a borrow
/// is in fact a two-phase borrow.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
crate enum TwoPhaseActivation {
NotTwoPhase,
NotActivated,
ActivatedAt(Location),
}
#[derive(Debug, Clone)]
crate struct BorrowData<'tcx> {
/// Location where the borrow reservation starts.
/// In many cases, this will be equal to the activation location but not always.
crate reserve_location: Location,
/// Location where the borrow is activated.
crate activation_location: TwoPhaseActivation,
/// What kind of borrow this is
crate kind: mir::BorrowKind,
/// The region for which this borrow is live
crate region: RegionVid,
/// Place from which we are borrowing
crate borrowed_place: mir::Place<'tcx>,
/// Place to which the borrow was stored
crate assigned_place: mir::Place<'tcx>,
}
impl<'tcx> fmt::Display for BorrowData<'tcx> {
fn fmt(&self, w: &mut fmt::Formatter<'_>) -> fmt::Result {
let kind = match self.kind {
mir::BorrowKind::Shared => "",
mir::BorrowKind::Shallow => "shallow ",
mir::BorrowKind::Unique => "uniq ",
mir::BorrowKind::Mut { .. } => "mut ",
};
write!(w, "&{:?} {}{:?}", self.region, kind, self.borrowed_place)
}
}
crate enum LocalsStateAtExit {
AllAreInvalidated,
SomeAreInvalidated { has_storage_dead_or_moved: BitSet<Local> }
}
impl LocalsStateAtExit {
fn build(
locals_are_invalidated_at_exit: bool,
body: &Body<'tcx>,
move_data: &MoveData<'tcx>
) -> Self {
struct HasStorageDead(BitSet<Local>);
impl<'tcx> Visitor<'tcx> for HasStorageDead {
fn visit_local(&mut self, local: &Local, ctx: PlaceContext, _: Location) {
if ctx == PlaceContext::NonUse(NonUseContext::StorageDead) {
self.0.insert(*local);
}
}
}
if locals_are_invalidated_at_exit {
LocalsStateAtExit::AllAreInvalidated
} else {
let mut has_storage_dead = HasStorageDead(BitSet::new_empty(body.local_decls.len()));
has_storage_dead.visit_body(body);
let mut has_storage_dead_or_moved = has_storage_dead.0;
for move_out in &move_data.moves {
if let Some(index) = move_data.base_local(move_out.path) {
has_storage_dead_or_moved.insert(index);
}
} | }
}
impl<'tcx> BorrowSet<'tcx> {
pub fn build(
tcx: TyCtxt<'tcx>,
body: &Body<'tcx>,
locals_are_invalidated_at_exit: bool,
move_data: &MoveData<'tcx>,
) -> Self {
let mut visitor = GatherBorrows {
tcx,
body,
idx_vec: IndexVec::new(),
location_map: Default::default(),
activation_map: Default::default(),
local_map: Default::default(),
pending_activations: Default::default(),
locals_state_at_exit:
LocalsStateAtExit::build(locals_are_invalidated_at_exit, body, move_data),
};
for (block, block_data) in traversal::preorder(body) {
visitor.visit_basic_block_data(block, block_data);
}
BorrowSet {
borrows: visitor.idx_vec,
location_map: visitor.location_map,
activation_map: visitor.activation_map,
local_map: visitor.local_map,
locals_state_at_exit: visitor.locals_state_at_exit,
}
}
crate fn activations_at_location(&self, location: Location) -> &[BorrowIndex] {
self.activation_map
.get(&location)
.map(|activations| &activations[..])
.unwrap_or(&[])
}
}
struct GatherBorrows<'a, 'tcx> {
tcx: TyCtxt<'tcx>,
body: &'a Body<'tcx>,
idx_vec: IndexVec<BorrowIndex, BorrowData<'tcx>>,
location_map: FxHashMap<Location, BorrowIndex>,
activation_map: FxHashMap<Location, Vec<BorrowIndex>>,
local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
/// When we encounter a 2-phase borrow statement, it will always
/// be assigning into a temporary TEMP:
///
/// TEMP = &foo
///
/// We add TEMP into this map with `b`, where `b` is the index of
/// the borrow. When we find a later use of this activation, we
/// remove from the map (and add to the "tombstone" set below).
pending_activations: FxHashMap<mir::Local, BorrowIndex>,
locals_state_at_exit: LocalsStateAtExit,
}
impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
fn visit_assign(
&mut self,
assigned_place: &mir::Place<'tcx>,
rvalue: &mir::Rvalue<'tcx>,
location: mir::Location,
) {
if let mir::Rvalue::Ref(region, kind, ref borrowed_place) = *rvalue {
if borrowed_place.ignore_borrow(
self.tcx, self.body, &self.locals_state_at_exit) {
return;
}
let region = region.to_region_vid();
let borrow = BorrowData {
kind,
region,
reserve_location: location,
activation_location: TwoPhaseActivation::NotTwoPhase,
borrowed_place: borrowed_place.clone(),
assigned_place: assigned_place.clone(),
};
let idx = self.idx_vec.push(borrow);
self.location_map.insert(location, idx);
self.insert_as_pending_if_two_phase(location, &assigned_place, kind, idx);
if let mir::PlaceBase::Local(local) = borrowed_place.base {
self.local_map.entry(local).or_default().insert(idx);
}
}
self.super_assign(assigned_place, rvalue, location)
}
fn visit_local(
&mut self,
temp: &Local,
context: PlaceContext,
location: Location,
) {
if !context.is_use() {
return;
}
// We found a use of some temporary TMP
// check whether we (earlier) saw a 2-phase borrow like
//
// TMP = &mut place
if let Some(&borrow_index) = self.pending_activations.get(temp) {
let borrow_data = &mut self.idx_vec[borrow_index];
// Watch out: the use of TMP in the borrow itself
// doesn't count as an activation. =)
if borrow_data.reserve_location == location &&
context == PlaceContext::MutatingUse(MutatingUseContext::Store)
{
return;
}
if let TwoPhaseActivation::ActivatedAt(other_location) =
borrow_data.activation_location {
span_bug!(
self.body.source_info(location).span,
"found two uses for 2-phase borrow temporary {:?}: \
{:?} and {:?}",
temp,
location,
other_location,
);
}
// Otherwise, this is the unique later use that we expect.
// Double check: This borrow is indeed a two-phase borrow (that is,
// we are 'transitioning' from `NotActivated` to `ActivatedAt`) and
// we've not found any other activations (checked above).
assert_eq!(
borrow_data.activation_location,
TwoPhaseActivation::NotActivated,
"never found an activation for this borrow!",
);
self.activation_map
.entry(location)
.or_default()
.push(borrow_index);
borrow_data.activation_location = TwoPhaseActivation::ActivatedAt(location);
}
}
fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: mir::Location) {
if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue {
// double-check that we already registered a Borrow | LocalsStateAtExit::SomeAreInvalidated{ has_storage_dead_or_moved }
} | random_line_split |
train_denoise_clouds.py | n_samples_matrix, _, _ = self.matrix.shape
f_surface = zarr.open('training_surfaces_libnoise.zarr', 'r')
self.surface = 1.0 - f_surface['surface'][:]
n_samples_surface, _ = self.surface.shape
f_clouds = zarr.open('training_clouds.zarr', 'r')
self.clouds = f_clouds['clouds'][:]
n_samples_clouds, _ = self.clouds.shape
self.index_matrix = np.random.randint(low=0, high=n_samples_matrix, size=self.n_training)
self.index_surface = np.random.randint(low=0, high=n_samples_surface, size=self.n_training)
self.index_clouds = np.random.randint(low=0, high=n_samples_clouds, size=(5, self.n_training))
def __getitem__(self, index):
Phi = self.matrix[self.index_matrix[index], :, :].astype('float32')
rho = 0.4 / self.eigenvals[self.index_matrix[index]]
Phi_split = Phi.reshape((5, 24, 3072))
surface = np.random.uniform(low=0.2, high=1.0) * self.surface[self.index_surface[index], :]
clouds = np.random.uniform(low=0.2, high=1.0, size=5)[:, None] * self.clouds[self.index_clouds[:, index], :]
d_split = np.zeros((5, 24))
for i in range(5):
d_split[i, :] = Phi_split[i, :, :] @ (clouds[i, :] + (1.0 - clouds[i, :])**2 * surface)
return Phi_split, surface.astype('float32'), clouds.astype('float32'), rho.astype('float32'), d_split.astype('float32')
def __len__(self):
return self.n_training
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, filename+'.best')
class Training(object):
def __init__(self, batch_size, validation_split=0.2, gpu=0, smooth=0.05, K=3, model_class='conv1d'):
self.cuda = torch.cuda.is_available()
self.gpu = gpu
self.smooth = smooth
self.device = torch.device(f"cuda:{self.gpu}" if self.cuda else "cpu")
# self.device = 'cpu'
self.batch_size = batch_size
self.model_class = model_class
self.K = K
if (NVIDIA_SMI):
nvidia_smi.nvmlInit()
self.handle = nvidia_smi.nvmlDeviceGetHandleByIndex(self.gpu)
print("Computing in {0} : {1}".format(self.device, nvidia_smi.nvmlDeviceGetName(self.handle)))
self.validation_split = validation_split
kwargs = {'num_workers': 4, 'pin_memory': False} if self.cuda else {}
if (model_class == 'conv1d'):
self.model = model.Network(K=self.K, L=32, device=self.device, model_class=model_class).to(self.device)
if (model_class == 'conv2d'):
self.model = model.Network(K=self.K, L=32, NSIDE=16, device=self.device, model_class=model_class).to(self.device)
print('N. total parameters : {0}'.format(sum(p.numel() for p in self.model.parameters() if p.requires_grad)))
self.train_dataset = Dataset(n_training=20000)
self.validation_dataset = Dataset(n_training=2000)
# Data loaders that will inject data during training
self.train_loader = torch.utils.data.DataLoader(self.train_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
self.validation_loader = torch.utils.data.DataLoader(self.validation_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
def init_optimize(self, epochs, lr, weight_decay, scheduler):
self.lr = lr
self.weight_decay = weight_decay
print('Learning rate : {0}'.format(lr))
self.n_epochs = epochs
if (self.model_class == 'conv1d'):
root = 'trained_denoise_clouds_1d'
if (self.model_class == 'conv2d'):
root = 'trained_denoise_clouds_2d'
p = pathlib.Path(f'{root}/')
p.mkdir(parents=True, exist_ok=True)
current_time = time.strftime("%Y-%m-%d-%H:%M:%S")
self.out_name = f'{root}/{current_time}'
# Copy model
file = model.__file__.split('/')[-1]
shutil.copyfile(model.__file__, '{0}_model.py'.format(self.out_name))
shutil.copyfile('{0}/{1}'.format(os.path.dirname(os.path.abspath(__file__)), file), '{0}_trainer.py'.format(self.out_name))
self.file_mode = 'w'
f = open('{0}_call.dat'.format(self.out_name), 'w')
f.write('python ' + ' '.join(sys.argv))
f.close()
f = open('{0}_hyper.dat'.format(self.out_name), 'w')
f.write('Learning_rate Weight_decay \n')
f.write('{0} {1}'.format(self.lr, self.weight_decay)) | self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
self.loss_fn = nn.MSELoss().to(self.device)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=scheduler, gamma=0.5)
np.random.seed(123)
self.surf0 = torch.tensor(np.random.rand(self.batch_size, 3072).astype('float32')).to(self.device)
self.surf0 = torch.zeros((self.batch_size, 3072)).to(self.device)
self.clouds0 = torch.tensor(np.random.rand(self.batch_size, 5, 3072).astype('float32')).to(self.device)
self.clouds0 = torch.zeros((self.batch_size, 5, 3072)).to(self.device)
torch.backends.cudnn.benchmark = True
def optimize(self):
self.loss = []
self.loss_val = []
best_loss = 1e10
trainF = open('{0}.loss.csv'.format(self.out_name), self.file_mode)
print('Model : {0}'.format(self.out_name))
for epoch in range(1, self.n_epochs + 1):
self.train(epoch)
self.test(epoch)
self.scheduler.step()
trainF.write('{},{},{}\n'.format(
epoch, self.loss[-1], self.loss_val[-1]))
trainF.flush()
is_best = self.loss_val[-1] < best_loss
best_loss = min(self.loss_val[-1], best_loss)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': self.model.state_dict(),
'best_loss': best_loss,
'optimizer': self.optimizer.state_dict(),
}, is_best, filename='{0}.pth'.format(self.out_name))
trainF.close()
def train(self, epoch):
self.model.train()
print("Epoch {0}/{1}".format(epoch, self.n_epochs))
t = tqdm(self.train_loader)
loss_avg = 0.0
n = 1
for param_group in self.optimizer.param_groups:
current_lr = param_group['lr']
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split.to(self.device)
self.optimizer.zero_grad()
surf, clouds, out_surface, out_clouds = self.model(d_split, self.surf0, self.clouds0, Phi_split, rho, n_epochs=5)
# Loss
loss = 0.0
for i in range(self.K):
loss += self.loss_fn(out_surface[i], surface)
# loss += self.loss_fn(out_clouds[i], clouds)
loss.backward()
self.optimizer.step()
if (batch_idx == 0):
loss_avg = loss.item()
else:
loss_avg = self.smooth * loss.item() + (1.0 - self.smooth) * loss_avg
if (NVIDIA_SMI):
tmp = nvidia_smi.nvmlDeviceGetUtilizationRates(self.handle)
t.set_postfix(loss=loss_avg, lr=current_lr, gpu=tmp.gpu, mem=tmp.memory)
else:
t.set_postfix(loss=loss_avg, lr=current_lr)
self.loss.append(loss_avg)
def test(self, epoch):
self.model.eval()
t = tqdm(self.validation_loader)
n = 1
loss_avg = 0.0
with torch.no_grad():
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split.to | f.close()
| random_line_split |
train_denoise_clouds.py |
f_surface = zarr.open('training_surfaces_libnoise.zarr', 'r')
self.surface = 1.0 - f_surface['surface'][:]
n_samples_surface, _ = self.surface.shape
f_clouds = zarr.open('training_clouds.zarr', 'r')
self.clouds = f_clouds['clouds'][:]
n_samples_clouds, _ = self.clouds.shape
self.index_matrix = np.random.randint(low=0, high=n_samples_matrix, size=self.n_training)
self.index_surface = np.random.randint(low=0, high=n_samples_surface, size=self.n_training)
self.index_clouds = np.random.randint(low=0, high=n_samples_clouds, size=(5, self.n_training))
def __getitem__(self, index):
Phi = self.matrix[self.index_matrix[index], :, :].astype('float32')
rho = 0.4 / self.eigenvals[self.index_matrix[index]]
Phi_split = Phi.reshape((5, 24, 3072))
surface = np.random.uniform(low=0.2, high=1.0) * self.surface[self.index_surface[index], :]
clouds = np.random.uniform(low=0.2, high=1.0, size=5)[:, None] * self.clouds[self.index_clouds[:, index], :]
d_split = np.zeros((5, 24))
for i in range(5):
d_split[i, :] = Phi_split[i, :, :] @ (clouds[i, :] + (1.0 - clouds[i, :])**2 * surface)
return Phi_split, surface.astype('float32'), clouds.astype('float32'), rho.astype('float32'), d_split.astype('float32')
def __len__(self):
return self.n_training
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, filename+'.best')
class Training(object):
def __init__(self, batch_size, validation_split=0.2, gpu=0, smooth=0.05, K=3, model_class='conv1d'):
self.cuda = torch.cuda.is_available()
self.gpu = gpu
self.smooth = smooth
self.device = torch.device(f"cuda:{self.gpu}" if self.cuda else "cpu")
# self.device = 'cpu'
self.batch_size = batch_size
self.model_class = model_class
self.K = K
if (NVIDIA_SMI):
nvidia_smi.nvmlInit()
self.handle = nvidia_smi.nvmlDeviceGetHandleByIndex(self.gpu)
print("Computing in {0} : {1}".format(self.device, nvidia_smi.nvmlDeviceGetName(self.handle)))
self.validation_split = validation_split
kwargs = {'num_workers': 4, 'pin_memory': False} if self.cuda else {}
if (model_class == 'conv1d'):
self.model = model.Network(K=self.K, L=32, device=self.device, model_class=model_class).to(self.device)
if (model_class == 'conv2d'):
self.model = model.Network(K=self.K, L=32, NSIDE=16, device=self.device, model_class=model_class).to(self.device)
print('N. total parameters : {0}'.format(sum(p.numel() for p in self.model.parameters() if p.requires_grad)))
self.train_dataset = Dataset(n_training=20000)
self.validation_dataset = Dataset(n_training=2000)
# Data loaders that will inject data during training
self.train_loader = torch.utils.data.DataLoader(self.train_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
self.validation_loader = torch.utils.data.DataLoader(self.validation_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
def init_optimize(self, epochs, lr, weight_decay, scheduler):
self.lr = lr
self.weight_decay = weight_decay
print('Learning rate : {0}'.format(lr))
self.n_epochs = epochs
if (self.model_class == 'conv1d'):
root = 'trained_denoise_clouds_1d'
if (self.model_class == 'conv2d'):
root = 'trained_denoise_clouds_2d'
p = pathlib.Path(f'{root}/')
p.mkdir(parents=True, exist_ok=True)
current_time = time.strftime("%Y-%m-%d-%H:%M:%S")
self.out_name = f'{root}/{current_time}'
# Copy model
file = model.__file__.split('/')[-1]
shutil.copyfile(model.__file__, '{0}_model.py'.format(self.out_name))
shutil.copyfile('{0}/{1}'.format(os.path.dirname(os.path.abspath(__file__)), file), '{0}_trainer.py'.format(self.out_name))
self.file_mode = 'w'
f = open('{0}_call.dat'.format(self.out_name), 'w')
f.write('python ' + ' '.join(sys.argv))
f.close()
f = open('{0}_hyper.dat'.format(self.out_name), 'w')
f.write('Learning_rate Weight_decay \n')
f.write('{0} {1}'.format(self.lr, self.weight_decay))
f.close()
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
self.loss_fn = nn.MSELoss().to(self.device)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=scheduler, gamma=0.5)
np.random.seed(123)
self.surf0 = torch.tensor(np.random.rand(self.batch_size, 3072).astype('float32')).to(self.device)
self.surf0 = torch.zeros((self.batch_size, 3072)).to(self.device)
self.clouds0 = torch.tensor(np.random.rand(self.batch_size, 5, 3072).astype('float32')).to(self.device)
self.clouds0 = torch.zeros((self.batch_size, 5, 3072)).to(self.device)
torch.backends.cudnn.benchmark = True
def optimize(self):
self.loss = []
self.loss_val = []
best_loss = 1e10
trainF = open('{0}.loss.csv'.format(self.out_name), self.file_mode)
print('Model : {0}'.format(self.out_name))
for epoch in range(1, self.n_epochs + 1):
self.train(epoch)
self.test(epoch)
self.scheduler.step()
trainF.write('{},{},{}\n'.format(
epoch, self.loss[-1], self.loss_val[-1]))
trainF.flush()
is_best = self.loss_val[-1] < best_loss
best_loss = min(self.loss_val[-1], best_loss)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': self.model.state_dict(),
'best_loss': best_loss,
'optimizer': self.optimizer.state_dict(),
}, is_best, filename='{0}.pth'.format(self.out_name))
trainF.close()
def train(self, epoch):
self.model.train()
print("Epoch {0}/{1}".format(epoch, self.n_epochs))
t = tqdm(self.train_loader)
loss_avg = 0.0
n = 1
for param_group in self.optimizer.param_groups:
current_lr = param_group['lr']
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split.to(self.device)
self.optimizer.zero_grad()
surf, clouds, out_surface, out_clouds = self.model(d_split, self.surf0, self.clouds0, Phi_split, rho, n_epochs=5)
# Loss
loss = 0.0
for i in range(self.K):
loss += self.loss_fn(out_surface[i], surface)
# loss += self.loss_fn(out_clouds[i], clouds)
loss.backward()
self.optimizer.step()
if (batch_idx == 0):
loss_avg = loss.item()
else:
loss_avg = self.smooth * loss.item() + (1.0 - self.smooth) * loss_avg
if (NVIDIA_SMI):
tmp = nvidia_smi.nvmlDeviceGetUtilizationRates(self.handle)
t.set_postfix(loss=loss_avg, lr=current_lr, gpu | """
Dataset class that will provide data during training. Modify it accordingly
for your dataset. This one shows how to do augmenting during training for a
very simple training set
"""
def __init__(self, n_training):
"""
Args:
n_training (int): number of training examples including augmenting
"""
super(Dataset, self).__init__()
self.n_training = n_training
f_matrix = zarr.open('training_matrices.zarr', 'r')
self.matrix = f_matrix['matrix'][:]
self.eigenvals = f_matrix['largest_eval'][:]
n_samples_matrix, _, _ = self.matrix.shape | identifier_body | |
train_denoise_clouds.py | n_samples_matrix, _, _ = self.matrix.shape
f_surface = zarr.open('training_surfaces_libnoise.zarr', 'r')
self.surface = 1.0 - f_surface['surface'][:]
n_samples_surface, _ = self.surface.shape
f_clouds = zarr.open('training_clouds.zarr', 'r')
self.clouds = f_clouds['clouds'][:]
n_samples_clouds, _ = self.clouds.shape
self.index_matrix = np.random.randint(low=0, high=n_samples_matrix, size=self.n_training)
self.index_surface = np.random.randint(low=0, high=n_samples_surface, size=self.n_training)
self.index_clouds = np.random.randint(low=0, high=n_samples_clouds, size=(5, self.n_training))
def | (self, index):
Phi = self.matrix[self.index_matrix[index], :, :].astype('float32')
rho = 0.4 / self.eigenvals[self.index_matrix[index]]
Phi_split = Phi.reshape((5, 24, 3072))
surface = np.random.uniform(low=0.2, high=1.0) * self.surface[self.index_surface[index], :]
clouds = np.random.uniform(low=0.2, high=1.0, size=5)[:, None] * self.clouds[self.index_clouds[:, index], :]
d_split = np.zeros((5, 24))
for i in range(5):
d_split[i, :] = Phi_split[i, :, :] @ (clouds[i, :] + (1.0 - clouds[i, :])**2 * surface)
return Phi_split, surface.astype('float32'), clouds.astype('float32'), rho.astype('float32'), d_split.astype('float32')
def __len__(self):
return self.n_training
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, filename+'.best')
class Training(object):
def __init__(self, batch_size, validation_split=0.2, gpu=0, smooth=0.05, K=3, model_class='conv1d'):
self.cuda = torch.cuda.is_available()
self.gpu = gpu
self.smooth = smooth
self.device = torch.device(f"cuda:{self.gpu}" if self.cuda else "cpu")
# self.device = 'cpu'
self.batch_size = batch_size
self.model_class = model_class
self.K = K
if (NVIDIA_SMI):
nvidia_smi.nvmlInit()
self.handle = nvidia_smi.nvmlDeviceGetHandleByIndex(self.gpu)
print("Computing in {0} : {1}".format(self.device, nvidia_smi.nvmlDeviceGetName(self.handle)))
self.validation_split = validation_split
kwargs = {'num_workers': 4, 'pin_memory': False} if self.cuda else {}
if (model_class == 'conv1d'):
self.model = model.Network(K=self.K, L=32, device=self.device, model_class=model_class).to(self.device)
if (model_class == 'conv2d'):
self.model = model.Network(K=self.K, L=32, NSIDE=16, device=self.device, model_class=model_class).to(self.device)
print('N. total parameters : {0}'.format(sum(p.numel() for p in self.model.parameters() if p.requires_grad)))
self.train_dataset = Dataset(n_training=20000)
self.validation_dataset = Dataset(n_training=2000)
# Data loaders that will inject data during training
self.train_loader = torch.utils.data.DataLoader(self.train_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
self.validation_loader = torch.utils.data.DataLoader(self.validation_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
def init_optimize(self, epochs, lr, weight_decay, scheduler):
self.lr = lr
self.weight_decay = weight_decay
print('Learning rate : {0}'.format(lr))
self.n_epochs = epochs
if (self.model_class == 'conv1d'):
root = 'trained_denoise_clouds_1d'
if (self.model_class == 'conv2d'):
root = 'trained_denoise_clouds_2d'
p = pathlib.Path(f'{root}/')
p.mkdir(parents=True, exist_ok=True)
current_time = time.strftime("%Y-%m-%d-%H:%M:%S")
self.out_name = f'{root}/{current_time}'
# Copy model
file = model.__file__.split('/')[-1]
shutil.copyfile(model.__file__, '{0}_model.py'.format(self.out_name))
shutil.copyfile('{0}/{1}'.format(os.path.dirname(os.path.abspath(__file__)), file), '{0}_trainer.py'.format(self.out_name))
self.file_mode = 'w'
f = open('{0}_call.dat'.format(self.out_name), 'w')
f.write('python ' + ' '.join(sys.argv))
f.close()
f = open('{0}_hyper.dat'.format(self.out_name), 'w')
f.write('Learning_rate Weight_decay \n')
f.write('{0} {1}'.format(self.lr, self.weight_decay))
f.close()
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
self.loss_fn = nn.MSELoss().to(self.device)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=scheduler, gamma=0.5)
np.random.seed(123)
self.surf0 = torch.tensor(np.random.rand(self.batch_size, 3072).astype('float32')).to(self.device)
self.surf0 = torch.zeros((self.batch_size, 3072)).to(self.device)
self.clouds0 = torch.tensor(np.random.rand(self.batch_size, 5, 3072).astype('float32')).to(self.device)
self.clouds0 = torch.zeros((self.batch_size, 5, 3072)).to(self.device)
torch.backends.cudnn.benchmark = True
def optimize(self):
self.loss = []
self.loss_val = []
best_loss = 1e10
trainF = open('{0}.loss.csv'.format(self.out_name), self.file_mode)
print('Model : {0}'.format(self.out_name))
for epoch in range(1, self.n_epochs + 1):
self.train(epoch)
self.test(epoch)
self.scheduler.step()
trainF.write('{},{},{}\n'.format(
epoch, self.loss[-1], self.loss_val[-1]))
trainF.flush()
is_best = self.loss_val[-1] < best_loss
best_loss = min(self.loss_val[-1], best_loss)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': self.model.state_dict(),
'best_loss': best_loss,
'optimizer': self.optimizer.state_dict(),
}, is_best, filename='{0}.pth'.format(self.out_name))
trainF.close()
def train(self, epoch):
self.model.train()
print("Epoch {0}/{1}".format(epoch, self.n_epochs))
t = tqdm(self.train_loader)
loss_avg = 0.0
n = 1
for param_group in self.optimizer.param_groups:
current_lr = param_group['lr']
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split.to(self.device)
self.optimizer.zero_grad()
surf, clouds, out_surface, out_clouds = self.model(d_split, self.surf0, self.clouds0, Phi_split, rho, n_epochs=5)
# Loss
loss = 0.0
for i in range(self.K):
loss += self.loss_fn(out_surface[i], surface)
# loss += self.loss_fn(out_clouds[i], clouds)
loss.backward()
self.optimizer.step()
if (batch_idx == 0):
loss_avg = loss.item()
else:
loss_avg = self.smooth * loss.item() + (1.0 - self.smooth) * loss_avg
if (NVIDIA_SMI):
tmp = nvidia_smi.nvmlDeviceGetUtilizationRates(self.handle)
t.set_postfix(loss=loss_avg, lr=current_lr, gpu=tmp.gpu, mem=tmp.memory)
else:
t.set_postfix(loss=loss_avg, lr=current_lr)
self.loss.append(loss_avg)
def test(self, epoch):
self.model.eval()
t = tqdm(self.validation_loader)
n = 1
loss_avg = 0.0
with torch.no_grad():
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split | __getitem__ | identifier_name |
train_denoise_clouds.py | n_samples_matrix, _, _ = self.matrix.shape
f_surface = zarr.open('training_surfaces_libnoise.zarr', 'r')
self.surface = 1.0 - f_surface['surface'][:]
n_samples_surface, _ = self.surface.shape
f_clouds = zarr.open('training_clouds.zarr', 'r')
self.clouds = f_clouds['clouds'][:]
n_samples_clouds, _ = self.clouds.shape
self.index_matrix = np.random.randint(low=0, high=n_samples_matrix, size=self.n_training)
self.index_surface = np.random.randint(low=0, high=n_samples_surface, size=self.n_training)
self.index_clouds = np.random.randint(low=0, high=n_samples_clouds, size=(5, self.n_training))
def __getitem__(self, index):
Phi = self.matrix[self.index_matrix[index], :, :].astype('float32')
rho = 0.4 / self.eigenvals[self.index_matrix[index]]
Phi_split = Phi.reshape((5, 24, 3072))
surface = np.random.uniform(low=0.2, high=1.0) * self.surface[self.index_surface[index], :]
clouds = np.random.uniform(low=0.2, high=1.0, size=5)[:, None] * self.clouds[self.index_clouds[:, index], :]
d_split = np.zeros((5, 24))
for i in range(5):
|
return Phi_split, surface.astype('float32'), clouds.astype('float32'), rho.astype('float32'), d_split.astype('float32')
def __len__(self):
return self.n_training
def save_checkpoint(state, is_best, filename='checkpoint.pth.tar'):
torch.save(state, filename)
if is_best:
shutil.copyfile(filename, filename+'.best')
class Training(object):
def __init__(self, batch_size, validation_split=0.2, gpu=0, smooth=0.05, K=3, model_class='conv1d'):
self.cuda = torch.cuda.is_available()
self.gpu = gpu
self.smooth = smooth
self.device = torch.device(f"cuda:{self.gpu}" if self.cuda else "cpu")
# self.device = 'cpu'
self.batch_size = batch_size
self.model_class = model_class
self.K = K
if (NVIDIA_SMI):
nvidia_smi.nvmlInit()
self.handle = nvidia_smi.nvmlDeviceGetHandleByIndex(self.gpu)
print("Computing in {0} : {1}".format(self.device, nvidia_smi.nvmlDeviceGetName(self.handle)))
self.validation_split = validation_split
kwargs = {'num_workers': 4, 'pin_memory': False} if self.cuda else {}
if (model_class == 'conv1d'):
self.model = model.Network(K=self.K, L=32, device=self.device, model_class=model_class).to(self.device)
if (model_class == 'conv2d'):
self.model = model.Network(K=self.K, L=32, NSIDE=16, device=self.device, model_class=model_class).to(self.device)
print('N. total parameters : {0}'.format(sum(p.numel() for p in self.model.parameters() if p.requires_grad)))
self.train_dataset = Dataset(n_training=20000)
self.validation_dataset = Dataset(n_training=2000)
# Data loaders that will inject data during training
self.train_loader = torch.utils.data.DataLoader(self.train_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
self.validation_loader = torch.utils.data.DataLoader(self.validation_dataset, batch_size=self.batch_size, shuffle=True, drop_last=True, **kwargs)
def init_optimize(self, epochs, lr, weight_decay, scheduler):
self.lr = lr
self.weight_decay = weight_decay
print('Learning rate : {0}'.format(lr))
self.n_epochs = epochs
if (self.model_class == 'conv1d'):
root = 'trained_denoise_clouds_1d'
if (self.model_class == 'conv2d'):
root = 'trained_denoise_clouds_2d'
p = pathlib.Path(f'{root}/')
p.mkdir(parents=True, exist_ok=True)
current_time = time.strftime("%Y-%m-%d-%H:%M:%S")
self.out_name = f'{root}/{current_time}'
# Copy model
file = model.__file__.split('/')[-1]
shutil.copyfile(model.__file__, '{0}_model.py'.format(self.out_name))
shutil.copyfile('{0}/{1}'.format(os.path.dirname(os.path.abspath(__file__)), file), '{0}_trainer.py'.format(self.out_name))
self.file_mode = 'w'
f = open('{0}_call.dat'.format(self.out_name), 'w')
f.write('python ' + ' '.join(sys.argv))
f.close()
f = open('{0}_hyper.dat'.format(self.out_name), 'w')
f.write('Learning_rate Weight_decay \n')
f.write('{0} {1}'.format(self.lr, self.weight_decay))
f.close()
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
self.loss_fn = nn.MSELoss().to(self.device)
self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=scheduler, gamma=0.5)
np.random.seed(123)
self.surf0 = torch.tensor(np.random.rand(self.batch_size, 3072).astype('float32')).to(self.device)
self.surf0 = torch.zeros((self.batch_size, 3072)).to(self.device)
self.clouds0 = torch.tensor(np.random.rand(self.batch_size, 5, 3072).astype('float32')).to(self.device)
self.clouds0 = torch.zeros((self.batch_size, 5, 3072)).to(self.device)
torch.backends.cudnn.benchmark = True
def optimize(self):
self.loss = []
self.loss_val = []
best_loss = 1e10
trainF = open('{0}.loss.csv'.format(self.out_name), self.file_mode)
print('Model : {0}'.format(self.out_name))
for epoch in range(1, self.n_epochs + 1):
self.train(epoch)
self.test(epoch)
self.scheduler.step()
trainF.write('{},{},{}\n'.format(
epoch, self.loss[-1], self.loss_val[-1]))
trainF.flush()
is_best = self.loss_val[-1] < best_loss
best_loss = min(self.loss_val[-1], best_loss)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': self.model.state_dict(),
'best_loss': best_loss,
'optimizer': self.optimizer.state_dict(),
}, is_best, filename='{0}.pth'.format(self.out_name))
trainF.close()
def train(self, epoch):
self.model.train()
print("Epoch {0}/{1}".format(epoch, self.n_epochs))
t = tqdm(self.train_loader)
loss_avg = 0.0
n = 1
for param_group in self.optimizer.param_groups:
current_lr = param_group['lr']
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split.to(self.device)
self.optimizer.zero_grad()
surf, clouds, out_surface, out_clouds = self.model(d_split, self.surf0, self.clouds0, Phi_split, rho, n_epochs=5)
# Loss
loss = 0.0
for i in range(self.K):
loss += self.loss_fn(out_surface[i], surface)
# loss += self.loss_fn(out_clouds[i], clouds)
loss.backward()
self.optimizer.step()
if (batch_idx == 0):
loss_avg = loss.item()
else:
loss_avg = self.smooth * loss.item() + (1.0 - self.smooth) * loss_avg
if (NVIDIA_SMI):
tmp = nvidia_smi.nvmlDeviceGetUtilizationRates(self.handle)
t.set_postfix(loss=loss_avg, lr=current_lr, gpu=tmp.gpu, mem=tmp.memory)
else:
t.set_postfix(loss=loss_avg, lr=current_lr)
self.loss.append(loss_avg)
def test(self, epoch):
self.model.eval()
t = tqdm(self.validation_loader)
n = 1
loss_avg = 0.0
with torch.no_grad():
for batch_idx, (Phi_split, surface, clouds, rho, d_split) in enumerate(t):
Phi_split, surface, clouds, rho, d_split = Phi_split.to(self.device), surface.to(self.device), clouds.to(self.device), rho.to(self.device), d_split.to | d_split[i, :] = Phi_split[i, :, :] @ (clouds[i, :] + (1.0 - clouds[i, :])**2 * surface) | conditional_block |
create_load_files.py |
conf = SparkConf().setAppName('word count')
sc = SparkContext(conf=conf)
sqlContext = SQLContext(sc)
schema = types.StructType([types.StructField('Word', types.StringType(), False),
types.StructField('Count', types.IntegerType(), False),
types.StructField('Percent', types.FloatType(), False)])
genre_list = ["crime", "fantasy", "young-adult", "romance", "comedy", "dystopia",
"action", "historical", "non-fiction", "science fiction", "self-help"]
no_of_genres = len(genre_list)
for genre in genre_list:
crime_words = sc.textFile('../../data/word_counts/' + genre + '_counts')
if genre == "young-adult":
genre = 'YA'
elif genre == "non-fiction":
genre = "NF"
elif genre == "science fiction":
genre = "SF"
elif genre == "self-help":
genre = "SH"
genre_bag_words = crime_words.map(bags_format)
genre_word_df = sqlContext.createDataFrame(genre_bag_words, schema=schema).cache()
genre_word_df.createOrReplaceTempView(genre + '_words')
# Input Files
books_data = pd.read_csv("../../data/batch_1/books.csv")
img_price_data = pd.read_csv("../../data/batch_1/image_and_price.csv")
desc_data = pd.read_csv("../../data/batch_1/description_all.csv")
amazon_data = pd.read_csv("../../data/batch_1/amazon.csv")
reviews_data = pd.read_csv("../../data/batch_1/reviews_users.csv")
# Created Files
out = csv.writer(codecs.open("../../data/batch_1/final_1.csv", "w", "utf-8"), delimiter=",", quoting=csv.QUOTE_ALL)
out.writerow(["ID", "Book Title", "ISBN", "Rating", "Author", "Language", "Pages", "Publication", "Publish Date",
"Publish Month", "Publish Year", "Genres", "Image", "Google Play", "Google Play URL", "Barnes and Noble",
"Barnes and Noble URL", "Indie Bound", "Indie Bound URL",
"Amazon", "Amazon URL", "R1", "R1 URL", "R2", "R2 URL", "R3", "R3 URL", "R4", "R4 URL", "R5", "R5 URL",
"GoodReads_Description", "Wiki_Description", "Readgeek_Description", "Riffle_Description",
"Amazon_Description", "crime", "fantasy", "young-adult", "romance", "comedy", "dystopia", "action",
"historical", "non-fiction", "science fiction", "self-help"])
out_user_review = csv.writer(codecs.open("../../data/batch_1/final_2.csv", "w", "utf-8"), delimiter=",",
quoting=csv.QUOTE_ALL)
out_user_review.writerow(["ID", "Book Title", "ISBN", "User ID", "User Name", "User URL", "Rating",
"Review Data", "Review"])
book_id = 100000 - 1
reviews_index = -1
month_dict = {v: k for k, v in enumerate(calendar.month_abbr)}
for index, row in books_data.iterrows():
book_id += 1
title = row["Book Title"]
print(str(index) + " " + title)
# Books CSV data
isbn = row["ISBN"]
rating = row["Rating"]
author = row["Author"]
if type(author) is float:
author = ""
language = row["Language"]
if type(language) is float:
language = ""
pages = row["Pages"]
if pages == "[]":
pages = -1
publication = row["Publication"]
if type(publication) is float:
publication = ""
url = row["Book URL"]
if type(url) is float:
url = ""
date_str = row["Publish Date"]
if type(date_str) is float:
pub_date = -1
pub_month = -1
pub_year = -1
else:
date_str_list = date_str.split(" ")
if len(date_str_list) == 3:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_date = int(re.findall(r'\d+', date_str_list[1])[0])
pub_year = int(date_str_list[2])
elif len(date_str_list) == 2:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_year = int(date_str_list[1])
elif len(date_str_list) == 1:
pub_date = -1
pub_month = -1
pub_year = int(date_str_list[0])
genres = row["Genres"]
if type(genres) is float:
genres = ""
# Image Price data
img_url = img_price_data["Book Image"][index]
if type(img_url) is float:
img_url = ""
gp_price = img_price_data["Google Play"][index]
if type(gp_price) is float or "http" in gp_price:
gp_price = ""
gp_url = img_price_data["Google Play URL"][index]
if type(gp_url) is float:
gp_url = ""
bnb_price = img_price_data["Barnes and Noble"][index]
if type(bnb_price) is float or "http" in bnb_price:
bnb_price = ""
bnb_url = img_price_data["Barnes and Noble URL"][index]
if type(bnb_url) is float:
bnb_url = ""
indie_price = img_price_data["Indie Bound"][index]
if type(indie_price) is float or "http" in indie_price:
indie_price = ""
indie_url = img_price_data["Indie Bound URL"][index]
if type(indie_url) is float:
indie_url = ""
# Amazon Data
amazon_price = amazon_data["Amazon Price"][index]
if type(amazon_price) is float or "http" in amazon_price:
amazon_price = ""
r1 = amazon_data["R1 Title"][index]
if type(r1) is float:
r1 = ""
r1_url = amazon_data["R1 URL"][index]
if type(r1_url) is float:
r1_url = ""
r2 = amazon_data["R2 Title"][index]
if type(r2) is float:
r2 = ""
r2_url = amazon_data["R2 URL"][index]
if type(r2_url) is float:
r2_url = ""
r3 = amazon_data["R3 Title"][index]
if type(r3) is float:
r3 = ""
r3_url = amazon_data["R3 URL"][index]
if type(r3_url) is float:
r3_url = ""
r4 = amazon_data["R4 Title"][index]
if type(r4) is float:
r4 = ""
r4_url = amazon_data["R4 URL"][index]
if type(r4_url) is float:
r4_url = ""
r5 = amazon_data["R5 Title"][index]
if type(r5) is float:
r5 = ""
r5_url = amazon_data["R5 URL"][index]
if type(r5_url) is float:
r5_url = ""
amazon_url = amazon_data["Book URL"][index]
if type(amazon_url) is float:
amazon_url = ""
# Description data
good_reads_desc = desc_data["GoodReads Description"][index]
if type(good_reads_desc) is float:
good_reads_desc = ""
good_reads_desc = give_clean_words_list(good_reads_desc)
wiki_desc = desc_data["Wikipedia Description"][index]
if type(wiki_desc) is float:
wiki_desc = ""
wiki_desc = give_clean_words_list(wiki_desc)
read_geek_desc = desc_data["Readgeek Description"][index]
if type(read_geek_desc) is float:
read_geek_desc = ""
read_geek_desc = give_clean_words_list(read_geek_desc)
riffle_desc = desc_data["Riffle Description"][index]
if type(riffle_desc) is float:
riffle_desc = ""
riffle_desc = give_clean_words_list(riffle_desc)
amazon_desc = desc_data["Amazon Description"][index]
if type(amazon_desc) is float:
amazon_desc = ""
amazon_desc = give_clean_words_list(amazon_desc)
output_result = [book_id, title, isbn, rating, author, language, pages, publication, pub_date, pub_month, pub_year,
genres, img_url, gp_price, gp_url, bnb_price, bnb_url, indie_price, indie_url, amazon_price,
amazon_url, r1, r1_url, r2, r2_url, r3, r3_url, r4, r4_url, r5, r5_url, good_reads_desc, wiki_desc,
read_geek_desc, riffle_desc, amazon_desc]
# Reviews File
no_comments = 0
while True:
reviews_index += 1
try:
| contents = line.split()
return str(contents[0]), int(contents[1]), float(contents[2]) | identifier_body | |
create_load_files.py | elif genre == "self-help":
genre = "SH"
genre_bag_words = crime_words.map(bags_format)
genre_word_df = sqlContext.createDataFrame(genre_bag_words, schema=schema).cache()
genre_word_df.createOrReplaceTempView(genre + '_words')
# Input Files
books_data = pd.read_csv("../../data/batch_1/books.csv")
img_price_data = pd.read_csv("../../data/batch_1/image_and_price.csv")
desc_data = pd.read_csv("../../data/batch_1/description_all.csv")
amazon_data = pd.read_csv("../../data/batch_1/amazon.csv")
reviews_data = pd.read_csv("../../data/batch_1/reviews_users.csv")
# Created Files
out = csv.writer(codecs.open("../../data/batch_1/final_1.csv", "w", "utf-8"), delimiter=",", quoting=csv.QUOTE_ALL)
out.writerow(["ID", "Book Title", "ISBN", "Rating", "Author", "Language", "Pages", "Publication", "Publish Date",
"Publish Month", "Publish Year", "Genres", "Image", "Google Play", "Google Play URL", "Barnes and Noble",
"Barnes and Noble URL", "Indie Bound", "Indie Bound URL",
"Amazon", "Amazon URL", "R1", "R1 URL", "R2", "R2 URL", "R3", "R3 URL", "R4", "R4 URL", "R5", "R5 URL",
"GoodReads_Description", "Wiki_Description", "Readgeek_Description", "Riffle_Description",
"Amazon_Description", "crime", "fantasy", "young-adult", "romance", "comedy", "dystopia", "action",
"historical", "non-fiction", "science fiction", "self-help"])
out_user_review = csv.writer(codecs.open("../../data/batch_1/final_2.csv", "w", "utf-8"), delimiter=",",
quoting=csv.QUOTE_ALL)
out_user_review.writerow(["ID", "Book Title", "ISBN", "User ID", "User Name", "User URL", "Rating",
"Review Data", "Review"])
book_id = 100000 - 1
reviews_index = -1
month_dict = {v: k for k, v in enumerate(calendar.month_abbr)}
for index, row in books_data.iterrows():
book_id += 1
title = row["Book Title"]
print(str(index) + " " + title)
# Books CSV data
isbn = row["ISBN"]
rating = row["Rating"]
author = row["Author"]
if type(author) is float:
author = ""
language = row["Language"]
if type(language) is float:
language = ""
pages = row["Pages"]
if pages == "[]":
pages = -1
publication = row["Publication"]
if type(publication) is float:
publication = ""
url = row["Book URL"]
if type(url) is float:
url = ""
date_str = row["Publish Date"]
if type(date_str) is float:
pub_date = -1
pub_month = -1
pub_year = -1
else:
date_str_list = date_str.split(" ")
if len(date_str_list) == 3:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_date = int(re.findall(r'\d+', date_str_list[1])[0])
pub_year = int(date_str_list[2])
elif len(date_str_list) == 2:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_year = int(date_str_list[1])
elif len(date_str_list) == 1:
pub_date = -1
pub_month = -1
pub_year = int(date_str_list[0])
genres = row["Genres"]
if type(genres) is float:
genres = ""
# Image Price data
img_url = img_price_data["Book Image"][index]
if type(img_url) is float:
img_url = ""
gp_price = img_price_data["Google Play"][index]
if type(gp_price) is float or "http" in gp_price:
gp_price = ""
gp_url = img_price_data["Google Play URL"][index]
if type(gp_url) is float:
gp_url = ""
bnb_price = img_price_data["Barnes and Noble"][index]
if type(bnb_price) is float or "http" in bnb_price:
bnb_price = ""
bnb_url = img_price_data["Barnes and Noble URL"][index]
if type(bnb_url) is float:
bnb_url = ""
indie_price = img_price_data["Indie Bound"][index]
if type(indie_price) is float or "http" in indie_price:
indie_price = ""
indie_url = img_price_data["Indie Bound URL"][index]
if type(indie_url) is float:
indie_url = ""
# Amazon Data
amazon_price = amazon_data["Amazon Price"][index]
if type(amazon_price) is float or "http" in amazon_price:
amazon_price = ""
r1 = amazon_data["R1 Title"][index]
if type(r1) is float:
r1 = ""
r1_url = amazon_data["R1 URL"][index]
if type(r1_url) is float:
r1_url = ""
r2 = amazon_data["R2 Title"][index]
if type(r2) is float:
r2 = ""
r2_url = amazon_data["R2 URL"][index]
if type(r2_url) is float:
r2_url = ""
r3 = amazon_data["R3 Title"][index]
if type(r3) is float:
r3 = ""
r3_url = amazon_data["R3 URL"][index]
if type(r3_url) is float:
r3_url = ""
r4 = amazon_data["R4 Title"][index]
if type(r4) is float:
r4 = ""
r4_url = amazon_data["R4 URL"][index]
if type(r4_url) is float:
r4_url = ""
r5 = amazon_data["R5 Title"][index]
if type(r5) is float:
|
r5_url = amazon_data["R5 URL"][index]
if type(r5_url) is float:
r5_url = ""
amazon_url = amazon_data["Book URL"][index]
if type(amazon_url) is float:
amazon_url = ""
# Description data
good_reads_desc = desc_data["GoodReads Description"][index]
if type(good_reads_desc) is float:
good_reads_desc = ""
good_reads_desc = give_clean_words_list(good_reads_desc)
wiki_desc = desc_data["Wikipedia Description"][index]
if type(wiki_desc) is float:
wiki_desc = ""
wiki_desc = give_clean_words_list(wiki_desc)
read_geek_desc = desc_data["Readgeek Description"][index]
if type(read_geek_desc) is float:
read_geek_desc = ""
read_geek_desc = give_clean_words_list(read_geek_desc)
riffle_desc = desc_data["Riffle Description"][index]
if type(riffle_desc) is float:
riffle_desc = ""
riffle_desc = give_clean_words_list(riffle_desc)
amazon_desc = desc_data["Amazon Description"][index]
if type(amazon_desc) is float:
amazon_desc = ""
amazon_desc = give_clean_words_list(amazon_desc)
output_result = [book_id, title, isbn, rating, author, language, pages, publication, pub_date, pub_month, pub_year,
genres, img_url, gp_price, gp_url, bnb_price, bnb_url, indie_price, indie_url, amazon_price,
amazon_url, r1, r1_url, r2, r2_url, r3, r3_url, r4, r4_url, r5, r5_url, good_reads_desc, wiki_desc,
read_geek_desc, riffle_desc, amazon_desc]
# Reviews File
no_comments = 0
while True:
reviews_index += 1
try:
review_isbn = reviews_data["ISBN"][reviews_index]
review_book_title = reviews_data["Book Title"][reviews_index]
except KeyError:
break
if review_book_title == title or review_isbn == isbn:
user_id = reviews_data["User ID"][reviews_index]
user_name = reviews_data["User Name"][reviews_index]
user_url = reviews_data["User URL"][reviews_index]
review_date = reviews_data["Review Date"][reviews_index]
review_text = reviews_data["Review"][reviews_index]
user_rating = reviews_data["Rating"][reviews_index]
if type(review_text) is float:
review_text = ""
review_text = give_clean_words_list(review_text)
out_user_review.writerow([book_id, title, isbn, user_id, user_name, user_url, user_rating,
review_date, review_text])
no_comments += 1
else:
reviews_index -= 1
break
print("Comments = " + str(no_comments))
# Genre Classifier
tokens = | r5 = "" | conditional_block |
create_load_files.py |
elif genre == "science fiction":
genre = "SF"
elif genre == "self-help":
genre = "SH"
genre_bag_words = crime_words.map(bags_format)
genre_word_df = sqlContext.createDataFrame(genre_bag_words, schema=schema).cache()
genre_word_df.createOrReplaceTempView(genre + '_words')
# Input Files
books_data = pd.read_csv("../../data/batch_1/books.csv")
img_price_data = pd.read_csv("../../data/batch_1/image_and_price.csv")
desc_data = pd.read_csv("../../data/batch_1/description_all.csv")
amazon_data = pd.read_csv("../../data/batch_1/amazon.csv")
reviews_data = pd.read_csv("../../data/batch_1/reviews_users.csv")
# Created Files
out = csv.writer(codecs.open("../../data/batch_1/final_1.csv", "w", "utf-8"), delimiter=",", quoting=csv.QUOTE_ALL)
out.writerow(["ID", "Book Title", "ISBN", "Rating", "Author", "Language", "Pages", "Publication", "Publish Date",
"Publish Month", "Publish Year", "Genres", "Image", "Google Play", "Google Play URL", "Barnes and Noble",
"Barnes and Noble URL", "Indie Bound", "Indie Bound URL",
"Amazon", "Amazon URL", "R1", "R1 URL", "R2", "R2 URL", "R3", "R3 URL", "R4", "R4 URL", "R5", "R5 URL",
"GoodReads_Description", "Wiki_Description", "Readgeek_Description", "Riffle_Description",
"Amazon_Description", "crime", "fantasy", "young-adult", "romance", "comedy", "dystopia", "action",
"historical", "non-fiction", "science fiction", "self-help"])
out_user_review = csv.writer(codecs.open("../../data/batch_1/final_2.csv", "w", "utf-8"), delimiter=",",
quoting=csv.QUOTE_ALL)
out_user_review.writerow(["ID", "Book Title", "ISBN", "User ID", "User Name", "User URL", "Rating",
"Review Data", "Review"])
book_id = 100000 - 1
reviews_index = -1
month_dict = {v: k for k, v in enumerate(calendar.month_abbr)}
for index, row in books_data.iterrows():
book_id += 1
title = row["Book Title"]
print(str(index) + " " + title)
# Books CSV data
isbn = row["ISBN"]
rating = row["Rating"]
author = row["Author"]
if type(author) is float:
author = ""
language = row["Language"]
if type(language) is float:
language = ""
pages = row["Pages"]
if pages == "[]":
pages = -1
publication = row["Publication"]
if type(publication) is float:
publication = ""
url = row["Book URL"]
if type(url) is float:
url = ""
date_str = row["Publish Date"]
if type(date_str) is float:
pub_date = -1
pub_month = -1
pub_year = -1
else:
date_str_list = date_str.split(" ")
if len(date_str_list) == 3:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_date = int(re.findall(r'\d+', date_str_list[1])[0])
pub_year = int(date_str_list[2])
elif len(date_str_list) == 2:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_year = int(date_str_list[1])
elif len(date_str_list) == 1:
pub_date = -1
pub_month = -1
pub_year = int(date_str_list[0])
genres = row["Genres"]
if type(genres) is float:
genres = ""
# Image Price data
img_url = img_price_data["Book Image"][index]
if type(img_url) is float:
img_url = ""
gp_price = img_price_data["Google Play"][index]
if type(gp_price) is float or "http" in gp_price:
gp_price = ""
gp_url = img_price_data["Google Play URL"][index]
if type(gp_url) is float:
gp_url = ""
bnb_price = img_price_data["Barnes and Noble"][index]
if type(bnb_price) is float or "http" in bnb_price:
bnb_price = ""
bnb_url = img_price_data["Barnes and Noble URL"][index]
if type(bnb_url) is float:
bnb_url = ""
indie_price = img_price_data["Indie Bound"][index]
if type(indie_price) is float or "http" in indie_price:
indie_price = ""
indie_url = img_price_data["Indie Bound URL"][index]
if type(indie_url) is float:
indie_url = ""
# Amazon Data
amazon_price = amazon_data["Amazon Price"][index]
if type(amazon_price) is float or "http" in amazon_price:
amazon_price = ""
r1 = amazon_data["R1 Title"][index]
if type(r1) is float:
r1 = ""
r1_url = amazon_data["R1 URL"][index]
if type(r1_url) is float:
r1_url = ""
r2 = amazon_data["R2 Title"][index]
if type(r2) is float:
r2 = ""
r2_url = amazon_data["R2 URL"][index]
if type(r2_url) is float:
r2_url = ""
r3 = amazon_data["R3 Title"][index]
if type(r3) is float:
r3 = ""
r3_url = amazon_data["R3 URL"][index]
if type(r3_url) is float:
r3_url = ""
r4 = amazon_data["R4 Title"][index]
if type(r4) is float:
r4 = ""
r4_url = amazon_data["R4 URL"][index]
if type(r4_url) is float:
r4_url = ""
r5 = amazon_data["R5 Title"][index]
if type(r5) is float:
r5 = ""
r5_url = amazon_data["R5 URL"][index]
if type(r5_url) is float:
r5_url = ""
amazon_url = amazon_data["Book URL"][index]
if type(amazon_url) is float:
amazon_url = ""
# Description data
good_reads_desc = desc_data["GoodReads Description"][index]
if type(good_reads_desc) is float:
good_reads_desc = ""
good_reads_desc = give_clean_words_list(good_reads_desc)
wiki_desc = desc_data["Wikipedia Description"][index]
if type(wiki_desc) is float:
wiki_desc = ""
wiki_desc = give_clean_words_list(wiki_desc)
read_geek_desc = desc_data["Readgeek Description"][index]
if type(read_geek_desc) is float:
read_geek_desc = ""
read_geek_desc = give_clean_words_list(read_geek_desc)
riffle_desc = desc_data["Riffle Description"][index]
if type(riffle_desc) is float:
riffle_desc = ""
riffle_desc = give_clean_words_list(riffle_desc)
amazon_desc = desc_data["Amazon Description"][index]
if type(amazon_desc) is float:
amazon_desc = ""
amazon_desc = give_clean_words_list(amazon_desc)
output_result = [book_id, title, isbn, rating, author, language, pages, publication, pub_date, pub_month, pub_year,
genres, img_url, gp_price, gp_url, bnb_price, bnb_url, indie_price, indie_url, amazon_price,
amazon_url, r1, r1_url, r2, r2_url, r3, r3_url, r4, r4_url, r5, r5_url, good_reads_desc, wiki_desc,
read_geek_desc, riffle_desc, amazon_desc]
# Reviews File
no_comments = 0
while True:
reviews_index += 1
try:
review_isbn = reviews_data["ISBN"][reviews_index]
review_book_title = reviews_data["Book Title"][reviews_index]
except KeyError:
break
if review_book_title == title or review_isbn == isbn:
user_id = reviews_data["User ID"][reviews_index]
user_name = reviews_data["User Name"][reviews_index]
user_url = reviews_data["User URL"][reviews_index]
review_date = reviews_data["Review Date"][reviews_index]
review_text = reviews_data["Review"][reviews_index]
user_rating = reviews_data["Rating"][reviews_index]
if type(review_text) is float:
review_text = ""
review_text = give_clean_words_list(review_text)
out_user_review.writerow([book_id, title, isbn, user_id, user_name, user_url, user_rating,
review_date, review_text])
no_comments += 1
else |
elif genre == "non-fiction":
genre = "NF" | random_line_split | |
create_load_files.py | (line):
contents = line.split()
return str(contents[0]), int(contents[1]), float(contents[2])
conf = SparkConf().setAppName('word count')
sc = SparkContext(conf=conf)
sqlContext = SQLContext(sc)
schema = types.StructType([types.StructField('Word', types.StringType(), False),
types.StructField('Count', types.IntegerType(), False),
types.StructField('Percent', types.FloatType(), False)])
genre_list = ["crime", "fantasy", "young-adult", "romance", "comedy", "dystopia",
"action", "historical", "non-fiction", "science fiction", "self-help"]
no_of_genres = len(genre_list)
for genre in genre_list:
crime_words = sc.textFile('../../data/word_counts/' + genre + '_counts')
if genre == "young-adult":
genre = 'YA'
elif genre == "non-fiction":
genre = "NF"
elif genre == "science fiction":
genre = "SF"
elif genre == "self-help":
genre = "SH"
genre_bag_words = crime_words.map(bags_format)
genre_word_df = sqlContext.createDataFrame(genre_bag_words, schema=schema).cache()
genre_word_df.createOrReplaceTempView(genre + '_words')
# Input Files
books_data = pd.read_csv("../../data/batch_1/books.csv")
img_price_data = pd.read_csv("../../data/batch_1/image_and_price.csv")
desc_data = pd.read_csv("../../data/batch_1/description_all.csv")
amazon_data = pd.read_csv("../../data/batch_1/amazon.csv")
reviews_data = pd.read_csv("../../data/batch_1/reviews_users.csv")
# Created Files
out = csv.writer(codecs.open("../../data/batch_1/final_1.csv", "w", "utf-8"), delimiter=",", quoting=csv.QUOTE_ALL)
out.writerow(["ID", "Book Title", "ISBN", "Rating", "Author", "Language", "Pages", "Publication", "Publish Date",
"Publish Month", "Publish Year", "Genres", "Image", "Google Play", "Google Play URL", "Barnes and Noble",
"Barnes and Noble URL", "Indie Bound", "Indie Bound URL",
"Amazon", "Amazon URL", "R1", "R1 URL", "R2", "R2 URL", "R3", "R3 URL", "R4", "R4 URL", "R5", "R5 URL",
"GoodReads_Description", "Wiki_Description", "Readgeek_Description", "Riffle_Description",
"Amazon_Description", "crime", "fantasy", "young-adult", "romance", "comedy", "dystopia", "action",
"historical", "non-fiction", "science fiction", "self-help"])
out_user_review = csv.writer(codecs.open("../../data/batch_1/final_2.csv", "w", "utf-8"), delimiter=",",
quoting=csv.QUOTE_ALL)
out_user_review.writerow(["ID", "Book Title", "ISBN", "User ID", "User Name", "User URL", "Rating",
"Review Data", "Review"])
book_id = 100000 - 1
reviews_index = -1
month_dict = {v: k for k, v in enumerate(calendar.month_abbr)}
for index, row in books_data.iterrows():
book_id += 1
title = row["Book Title"]
print(str(index) + " " + title)
# Books CSV data
isbn = row["ISBN"]
rating = row["Rating"]
author = row["Author"]
if type(author) is float:
author = ""
language = row["Language"]
if type(language) is float:
language = ""
pages = row["Pages"]
if pages == "[]":
pages = -1
publication = row["Publication"]
if type(publication) is float:
publication = ""
url = row["Book URL"]
if type(url) is float:
url = ""
date_str = row["Publish Date"]
if type(date_str) is float:
pub_date = -1
pub_month = -1
pub_year = -1
else:
date_str_list = date_str.split(" ")
if len(date_str_list) == 3:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_date = int(re.findall(r'\d+', date_str_list[1])[0])
pub_year = int(date_str_list[2])
elif len(date_str_list) == 2:
pub_month = int(month_dict[date_str_list[0][0:3]])
pub_year = int(date_str_list[1])
elif len(date_str_list) == 1:
pub_date = -1
pub_month = -1
pub_year = int(date_str_list[0])
genres = row["Genres"]
if type(genres) is float:
genres = ""
# Image Price data
img_url = img_price_data["Book Image"][index]
if type(img_url) is float:
img_url = ""
gp_price = img_price_data["Google Play"][index]
if type(gp_price) is float or "http" in gp_price:
gp_price = ""
gp_url = img_price_data["Google Play URL"][index]
if type(gp_url) is float:
gp_url = ""
bnb_price = img_price_data["Barnes and Noble"][index]
if type(bnb_price) is float or "http" in bnb_price:
bnb_price = ""
bnb_url = img_price_data["Barnes and Noble URL"][index]
if type(bnb_url) is float:
bnb_url = ""
indie_price = img_price_data["Indie Bound"][index]
if type(indie_price) is float or "http" in indie_price:
indie_price = ""
indie_url = img_price_data["Indie Bound URL"][index]
if type(indie_url) is float:
indie_url = ""
# Amazon Data
amazon_price = amazon_data["Amazon Price"][index]
if type(amazon_price) is float or "http" in amazon_price:
amazon_price = ""
r1 = amazon_data["R1 Title"][index]
if type(r1) is float:
r1 = ""
r1_url = amazon_data["R1 URL"][index]
if type(r1_url) is float:
r1_url = ""
r2 = amazon_data["R2 Title"][index]
if type(r2) is float:
r2 = ""
r2_url = amazon_data["R2 URL"][index]
if type(r2_url) is float:
r2_url = ""
r3 = amazon_data["R3 Title"][index]
if type(r3) is float:
r3 = ""
r3_url = amazon_data["R3 URL"][index]
if type(r3_url) is float:
r3_url = ""
r4 = amazon_data["R4 Title"][index]
if type(r4) is float:
r4 = ""
r4_url = amazon_data["R4 URL"][index]
if type(r4_url) is float:
r4_url = ""
r5 = amazon_data["R5 Title"][index]
if type(r5) is float:
r5 = ""
r5_url = amazon_data["R5 URL"][index]
if type(r5_url) is float:
r5_url = ""
amazon_url = amazon_data["Book URL"][index]
if type(amazon_url) is float:
amazon_url = ""
# Description data
good_reads_desc = desc_data["GoodReads Description"][index]
if type(good_reads_desc) is float:
good_reads_desc = ""
good_reads_desc = give_clean_words_list(good_reads_desc)
wiki_desc = desc_data["Wikipedia Description"][index]
if type(wiki_desc) is float:
wiki_desc = ""
wiki_desc = give_clean_words_list(wiki_desc)
read_geek_desc = desc_data["Readgeek Description"][index]
if type(read_geek_desc) is float:
read_geek_desc = ""
read_geek_desc = give_clean_words_list(read_geek_desc)
riffle_desc = desc_data["Riffle Description"][index]
if type(riffle_desc) is float:
riffle_desc = ""
riffle_desc = give_clean_words_list(riffle_desc)
amazon_desc = desc_data["Amazon Description"][index]
if type(amazon_desc) is float:
amazon_desc = ""
amazon_desc = give_clean_words_list(amazon_desc)
output_result = [book_id, title, isbn, rating, author, language, pages, publication, pub_date, pub_month, pub_year,
genres, img_url, gp_price, gp_url, bnb_price, bnb_url, indie_price, indie_url, amazon_price,
amazon_url, r1, r1_url, r2, r2_url, r3, r3_url, r4, r4_url, r5, r5_url, good_reads_desc, wiki_desc,
read_geek_desc, riffle_desc, amazon_desc]
# Reviews File
no_comments = 0
while True:
reviews_index += 1
| bags_format | identifier_name | |
zigzag_graph.rs | = self.base_graph().degree() + expanded_parents.len();
for ii in 0..(self.degree() - current_length) {
if self.reversed() {
parents[ii + current_length] = self.size() - 1
} else {
parents[ii + current_length] = 0
}
}
});
assert!(parents.len() == self.degree());
if self.forward() {
parents.sort();
} else {
// Sort in reverse order.
parents.sort_by(|a, b| a.cmp(b).reverse());
}
assert!(parents.iter().all(|p| if self.forward() {
*p <= raw_node
} else {
*p >= raw_node
}));
}
fn seed(&self) -> [u32; 7] {
self.base_graph().seed()
}
fn new(nodes: usize, base_degree: usize, expansion_degree: usize, seed: [u32; 7]) -> Self {
Z::new_zigzag(nodes, base_degree, expansion_degree, seed)
}
fn forward(&self) -> bool {
!self.reversed()
}
}
impl<'a, H, G> ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
// Assign `expansion_degree` parents to `node` using an invertible function. That
// means we can't just generate random values between `[0, size())`, we need to
// expand the search space (domain) to accommodate every unique parent assignment
// generated here. This can be visualized more clearly as a matrix where the each
// new parent of each new node is assigned a unique `index`:
//
//
// | Parent 1 | Parent 2 | Parent 3 |
//
// | Node 1 | 0 | 1 | 2 |
//
// | Node 2 | 3 | 4 | 5 |
//
// | Node 3 | 6 | 7 | 8 |
//
// | Node 4 | 9 | A | B |
//
// This starting `index` will be shuffled to another position to generate a
// parent-child relationship, e.g., if generating the parents for the second node,
// `permute` would be called with values `[3; 4; 5]` that would be mapped to other
// indexes in the search space of `[0, B]`, say, values `[A; 0; 4]`, that would
// correspond to nodes numbered `[4; 1, 2]` which will become the parents of the
// second node. In a later pass invalid parents like 2, self-referencing, and parents
// with indexes bigger than 2 (if in the `forward` direction, smaller than 2 if the
// inverse), will be removed.
//
// Since `permute` is a bijective function which has the inverse `invert_permute`,
// it is guaranteed that when looking for the parents in the `reversed` direction
// the child `node` used earlier will now actually be the parent of the output
// parents generated before (inverting the relationship). Following the example,
// in the reverse direction, when looking for the parents of, say, node 1,
// `invert_permute` (that maps back the output of `permute` to its input) would
// receive the indexes `[0; 1; 2]`, where the index `0` is guaranteed to map back
// to the index `4` that generated it earlier, corresponding to the node 2, inverting
// in fact the child-parent relationship.
fn correspondent(&self, node: usize, i: usize) -> usize {
let a = (node * self.expansion_degree) as feistel::Index + i as feistel::Index;
let feistel_keys = &[1, 2, 3, 4];
let transformed = if self.reversed {
feistel::invert_permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
} else {
feistel::permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
};
transformed as usize / self.expansion_degree
// Collapse the output in the matrix search space to the row of the corresponding
// node (losing the column information, that will be regenerated later when calling
// back this function in the `reversed` direction).
}
// Read the `node` entry in the parents cache (which may not exist) for
// the current direction set in the graph and return a copy of it (or
// `None` to signal a cache miss).
fn contains_parents_cache(&self, node: usize) -> bool {
if self.use_cache {
if let Some(ref cache) = PARENT_CACHE.read().unwrap().get(&self.id) {
if self.forward() {
cache.contains_forward(node as u32)
} else {
cache.contains_reverse(node as u32)
}
} else {
false
}
} else {
false
}
}
fn generate_expanded_parents(&self, node: usize) -> Vec<u32> {
(0..self.expansion_degree)
.filter_map(|i| {
let other = self.correspondent(node, i);
if self.reversed {
if other > node {
Some(other as u32)
} else {
None
}
} else if other < node {
Some(other as u32)
} else {
None
}
})
.collect()
}
}
impl<'a, H, G> ZigZag for ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
type BaseHasher = H;
type BaseGraph = G;
fn new_zigzag(
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self {
Self::new(None, nodes, base_degree, expansion_degree, seed)
}
/// To zigzag a graph, we just toggle its reversed field.
/// All the real work happens when we calculate node parents on-demand.
// We always share the two caches (forward/reversed) between
// ZigZag graphs even if each graph will use only one of those
// caches (depending of its direction). This allows to propagate
// the caches across different layers, where consecutive even+odd
// layers have inverse directions.
fn zigzag(&self) -> Self {
let mut zigzag = self.clone();
zigzag.reversed = !zigzag.reversed;
zigzag
}
fn base_graph(&self) -> Self::BaseGraph {
self.base_graph.clone()
}
fn expansion_degree(&self) -> usize {
self.expansion_degree
}
fn reversed(&self) -> bool {
self.reversed
}
// TODO: Optimization: Evaluate providing an `all_parents` (and hence
// `all_expanded_parents`) method that would return the entire cache
// in a single lock operation, or at least (if the cache is not big enough)
// it would allow to batch parents calculations with that single lock. Also,
// since there is a reciprocity between forward and reversed parents,
// we would only need to compute the parents in one direction and with
// that fill both caches.
#[inline]
fn expanded_parents<F, T>(&self, node: usize, mut cb: F) -> T
where
F: FnMut(&Vec<u32>) -> T,
{
if !self.use_cache {
// No cache usage, generate on demand.
return cb(&self.generate_expanded_parents(node));
}
// Check if we need to fill the cache.
if !self.contains_parents_cache(node) {
// Cache is empty so we need to generate the parents.
let parents = self.generate_expanded_parents(node);
// Store the newly generated cached value.
let mut cache_lock = PARENT_CACHE.write().unwrap();
let cache = cache_lock
.get_mut(&self.id)
.expect("Invalid cache construction");
if self.forward() {
cache.write_forward(node as u32, parents);
} else {
cache.write_reverse(node as u32, parents);
}
}
// We made sure the cache is filled above, now we can return the value.
let cache_lock = PARENT_CACHE.read().unwrap();
let cache = cache_lock
.get(&self.id)
.expect("Invalid cache construction");
if self.forward() {
cache.read_forward(node as u32, |parents| cb(parents.unwrap()))
} else | {
cache.read_reverse(node as u32, |parents| cb(parents.unwrap()))
} | conditional_block | |
zigzag_graph.rs | new graph with expansion component inverted and a distinct
/// base DRG graph -- with the direction of drg connections reversed. (i.e. from high-to-low nodes).
/// The name is 'weird', but so is the operation -- hence the choice.
fn zigzag(&self) -> Self;
/// Constructs a new graph.
fn base_graph(&self) -> Self::BaseGraph;
fn expansion_degree(&self) -> usize;
fn reversed(&self) -> bool;
fn expanded_parents<F, T>(&self, node: usize, cb: F) -> T
where
F: FnMut(&Vec<u32>) -> T;
fn real_index(&self, i: usize) -> usize;
fn new_zigzag(
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self;
}
impl<Z: ZigZag> Graph<Z::BaseHasher> for Z {
fn size(&self) -> usize {
self.base_graph().size()
}
fn degree(&self) -> usize {
self.base_graph().degree() + self.expansion_degree()
}
#[inline]
fn parents(&self, raw_node: usize, parents: &mut [usize]) {
// If graph is reversed, use real_index to convert index to reversed index.
// So we convert a raw reversed node to an unreversed node, calculate its parents,
// then convert the parents to reversed.
self.base_graph()
.parents(self.real_index(raw_node), parents);
for parent in parents.iter_mut().take(self.base_graph().degree()) {
*parent = self.real_index(*parent);
}
// expanded_parents takes raw_node
self.expanded_parents(raw_node, |expanded_parents| {
for (ii, value) in expanded_parents.iter().enumerate() {
parents[ii + self.base_graph().degree()] = *value as usize
}
// Pad so all nodes have correct degree.
let current_length = self.base_graph().degree() + expanded_parents.len();
for ii in 0..(self.degree() - current_length) {
if self.reversed() {
parents[ii + current_length] = self.size() - 1
} else {
parents[ii + current_length] = 0
}
}
});
assert!(parents.len() == self.degree());
if self.forward() {
parents.sort();
} else {
// Sort in reverse order.
parents.sort_by(|a, b| a.cmp(b).reverse());
}
assert!(parents.iter().all(|p| if self.forward() {
*p <= raw_node
} else {
*p >= raw_node
}));
}
fn seed(&self) -> [u32; 7] {
self.base_graph().seed()
}
fn new(nodes: usize, base_degree: usize, expansion_degree: usize, seed: [u32; 7]) -> Self {
Z::new_zigzag(nodes, base_degree, expansion_degree, seed)
}
fn forward(&self) -> bool {
!self.reversed()
}
}
impl<'a, H, G> ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
// Assign `expansion_degree` parents to `node` using an invertible function. That
// means we can't just generate random values between `[0, size())`, we need to
// expand the search space (domain) to accommodate every unique parent assignment
// generated here. This can be visualized more clearly as a matrix where the each
// new parent of each new node is assigned a unique `index`:
//
//
// | Parent 1 | Parent 2 | Parent 3 |
//
// | Node 1 | 0 | 1 | 2 |
//
// | Node 2 | 3 | 4 | 5 |
//
// | Node 3 | 6 | 7 | 8 |
//
// | Node 4 | 9 | A | B |
//
// This starting `index` will be shuffled to another position to generate a
// parent-child relationship, e.g., if generating the parents for the second node,
// `permute` would be called with values `[3; 4; 5]` that would be mapped to other
// indexes in the search space of `[0, B]`, say, values `[A; 0; 4]`, that would
// correspond to nodes numbered `[4; 1, 2]` which will become the parents of the
// second node. In a later pass invalid parents like 2, self-referencing, and parents
// with indexes bigger than 2 (if in the `forward` direction, smaller than 2 if the
// inverse), will be removed.
//
// Since `permute` is a bijective function which has the inverse `invert_permute`,
// it is guaranteed that when looking for the parents in the `reversed` direction
// the child `node` used earlier will now actually be the parent of the output
// parents generated before (inverting the relationship). Following the example,
// in the reverse direction, when looking for the parents of, say, node 1,
// `invert_permute` (that maps back the output of `permute` to its input) would
// receive the indexes `[0; 1; 2]`, where the index `0` is guaranteed to map back
// to the index `4` that generated it earlier, corresponding to the node 2, inverting
// in fact the child-parent relationship.
fn correspondent(&self, node: usize, i: usize) -> usize {
let a = (node * self.expansion_degree) as feistel::Index + i as feistel::Index;
let feistel_keys = &[1, 2, 3, 4];
let transformed = if self.reversed {
feistel::invert_permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
} else {
feistel::permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
};
transformed as usize / self.expansion_degree
// Collapse the output in the matrix search space to the row of the corresponding
// node (losing the column information, that will be regenerated later when calling
// back this function in the `reversed` direction).
}
// Read the `node` entry in the parents cache (which may not exist) for
// the current direction set in the graph and return a copy of it (or
// `None` to signal a cache miss).
fn contains_parents_cache(&self, node: usize) -> bool {
if self.use_cache {
if let Some(ref cache) = PARENT_CACHE.read().unwrap().get(&self.id) {
if self.forward() {
cache.contains_forward(node as u32)
} else {
cache.contains_reverse(node as u32)
}
} else {
false
}
} else {
false
}
}
fn generate_expanded_parents(&self, node: usize) -> Vec<u32> {
(0..self.expansion_degree)
.filter_map(|i| {
let other = self.correspondent(node, i);
if self.reversed {
if other > node {
Some(other as u32)
} else {
None
}
} else if other < node {
Some(other as u32)
} else {
None
}
})
.collect()
}
}
impl<'a, H, G> ZigZag for ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
type BaseHasher = H;
type BaseGraph = G;
fn new_zigzag(
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self {
Self::new(None, nodes, base_degree, expansion_degree, seed)
}
/// To zigzag a graph, we just toggle its reversed field.
/// All the real work happens when we calculate node parents on-demand.
// We always share the two caches (forward/reversed) between
// ZigZag graphs even if each graph will use only one of those
// caches (depending of its direction). This allows to propagate
// the caches across different layers, where consecutive even+odd
// layers have inverse directions.
fn zigzag(&self) -> Self {
let mut zigzag = self.clone();
zigzag.reversed = !zigzag.reversed;
zigzag
}
fn base_graph(&self) -> Self::BaseGraph {
self.base_graph.clone()
}
fn | expansion_degree | identifier_name | |
zigzag_graph.rs | ARENT_CACHE
.write()
.unwrap()
.insert(res.id.clone(), ParentCache::new(nodes as u32));
}
}
res
}
}
impl<H, G> ParameterSetMetadata for ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
fn identifier(&self) -> String {
self.id.clone()
}
fn sector_size(&self) -> u64 {
self.base_graph.sector_size()
}
}
pub trait ZigZag: ::std::fmt::Debug + Clone + PartialEq + Eq {
type BaseHasher: Hasher;
type BaseGraph: Graph<Self::BaseHasher>;
/// zigzag returns a new graph with expansion component inverted and a distinct
/// base DRG graph -- with the direction of drg connections reversed. (i.e. from high-to-low nodes).
/// The name is 'weird', but so is the operation -- hence the choice.
fn zigzag(&self) -> Self;
/// Constructs a new graph.
fn base_graph(&self) -> Self::BaseGraph;
fn expansion_degree(&self) -> usize;
fn reversed(&self) -> bool;
fn expanded_parents<F, T>(&self, node: usize, cb: F) -> T
where
F: FnMut(&Vec<u32>) -> T;
fn real_index(&self, i: usize) -> usize;
fn new_zigzag(
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self;
}
impl<Z: ZigZag> Graph<Z::BaseHasher> for Z {
fn size(&self) -> usize {
self.base_graph().size()
}
fn degree(&self) -> usize {
self.base_graph().degree() + self.expansion_degree()
}
#[inline]
fn parents(&self, raw_node: usize, parents: &mut [usize]) {
// If graph is reversed, use real_index to convert index to reversed index.
// So we convert a raw reversed node to an unreversed node, calculate its parents,
// then convert the parents to reversed.
self.base_graph()
.parents(self.real_index(raw_node), parents);
for parent in parents.iter_mut().take(self.base_graph().degree()) {
*parent = self.real_index(*parent);
}
// expanded_parents takes raw_node
self.expanded_parents(raw_node, |expanded_parents| {
for (ii, value) in expanded_parents.iter().enumerate() {
parents[ii + self.base_graph().degree()] = *value as usize
}
// Pad so all nodes have correct degree.
let current_length = self.base_graph().degree() + expanded_parents.len();
for ii in 0..(self.degree() - current_length) {
if self.reversed() {
parents[ii + current_length] = self.size() - 1
} else {
parents[ii + current_length] = 0
}
}
});
assert!(parents.len() == self.degree());
if self.forward() {
parents.sort();
} else {
// Sort in reverse order.
parents.sort_by(|a, b| a.cmp(b).reverse());
}
assert!(parents.iter().all(|p| if self.forward() {
*p <= raw_node
} else {
*p >= raw_node
}));
}
fn seed(&self) -> [u32; 7] {
self.base_graph().seed()
}
fn new(nodes: usize, base_degree: usize, expansion_degree: usize, seed: [u32; 7]) -> Self {
Z::new_zigzag(nodes, base_degree, expansion_degree, seed)
}
fn forward(&self) -> bool {
!self.reversed()
}
}
impl<'a, H, G> ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
// Assign `expansion_degree` parents to `node` using an invertible function. That
// means we can't just generate random values between `[0, size())`, we need to
// expand the search space (domain) to accommodate every unique parent assignment
// generated here. This can be visualized more clearly as a matrix where the each
// new parent of each new node is assigned a unique `index`:
//
//
// | Parent 1 | Parent 2 | Parent 3 |
//
// | Node 1 | 0 | 1 | 2 |
//
// | Node 2 | 3 | 4 | 5 |
//
// | Node 3 | 6 | 7 | 8 |
//
// | Node 4 | 9 | A | B |
//
// This starting `index` will be shuffled to another position to generate a
// parent-child relationship, e.g., if generating the parents for the second node,
// `permute` would be called with values `[3; 4; 5]` that would be mapped to other
// indexes in the search space of `[0, B]`, say, values `[A; 0; 4]`, that would
// correspond to nodes numbered `[4; 1, 2]` which will become the parents of the
// second node. In a later pass invalid parents like 2, self-referencing, and parents
// with indexes bigger than 2 (if in the `forward` direction, smaller than 2 if the
// inverse), will be removed.
//
// Since `permute` is a bijective function which has the inverse `invert_permute`,
// it is guaranteed that when looking for the parents in the `reversed` direction
// the child `node` used earlier will now actually be the parent of the output
// parents generated before (inverting the relationship). Following the example,
// in the reverse direction, when looking for the parents of, say, node 1,
// `invert_permute` (that maps back the output of `permute` to its input) would
// receive the indexes `[0; 1; 2]`, where the index `0` is guaranteed to map back
// to the index `4` that generated it earlier, corresponding to the node 2, inverting
// in fact the child-parent relationship.
fn correspondent(&self, node: usize, i: usize) -> usize {
let a = (node * self.expansion_degree) as feistel::Index + i as feistel::Index;
let feistel_keys = &[1, 2, 3, 4];
let transformed = if self.reversed {
feistel::invert_permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
} else {
feistel::permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
};
transformed as usize / self.expansion_degree
// Collapse the output in the matrix search space to the row of the corresponding
// node (losing the column information, that will be regenerated later when calling
// back this function in the `reversed` direction).
}
// Read the `node` entry in the parents cache (which may not exist) for
// the current direction set in the graph and return a copy of it (or
// `None` to signal a cache miss).
fn contains_parents_cache(&self, node: usize) -> bool {
if self.use_cache {
if let Some(ref cache) = PARENT_CACHE.read().unwrap().get(&self.id) {
if self.forward() {
cache.contains_forward(node as u32)
} else {
cache.contains_reverse(node as u32)
}
} else {
false
}
} else {
false
}
}
fn generate_expanded_parents(&self, node: usize) -> Vec<u32> {
(0..self.expansion_degree)
.filter_map(|i| {
let other = self.correspondent(node, i);
if self.reversed {
if other > node {
Some(other as u32)
} else {
None
}
} else if other < node {
Some(other as u32)
} else {
None
}
})
.collect()
}
}
impl<'a, H, G> ZigZag for ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
type BaseHasher = H;
type BaseGraph = G;
fn new_zigzag(
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self | {
Self::new(None, nodes, base_degree, expansion_degree, seed)
} | identifier_body | |
zigzag_graph.rs | (
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self;
}
impl<Z: ZigZag> Graph<Z::BaseHasher> for Z {
fn size(&self) -> usize {
self.base_graph().size()
}
fn degree(&self) -> usize {
self.base_graph().degree() + self.expansion_degree()
}
#[inline]
fn parents(&self, raw_node: usize, parents: &mut [usize]) {
// If graph is reversed, use real_index to convert index to reversed index.
// So we convert a raw reversed node to an unreversed node, calculate its parents,
// then convert the parents to reversed.
self.base_graph()
.parents(self.real_index(raw_node), parents);
for parent in parents.iter_mut().take(self.base_graph().degree()) {
*parent = self.real_index(*parent);
}
// expanded_parents takes raw_node
self.expanded_parents(raw_node, |expanded_parents| {
for (ii, value) in expanded_parents.iter().enumerate() {
parents[ii + self.base_graph().degree()] = *value as usize
}
// Pad so all nodes have correct degree.
let current_length = self.base_graph().degree() + expanded_parents.len();
for ii in 0..(self.degree() - current_length) {
if self.reversed() {
parents[ii + current_length] = self.size() - 1
} else {
parents[ii + current_length] = 0
}
}
});
assert!(parents.len() == self.degree());
if self.forward() {
parents.sort();
} else {
// Sort in reverse order.
parents.sort_by(|a, b| a.cmp(b).reverse());
}
assert!(parents.iter().all(|p| if self.forward() {
*p <= raw_node
} else {
*p >= raw_node
}));
}
fn seed(&self) -> [u32; 7] {
self.base_graph().seed()
}
fn new(nodes: usize, base_degree: usize, expansion_degree: usize, seed: [u32; 7]) -> Self {
Z::new_zigzag(nodes, base_degree, expansion_degree, seed)
}
fn forward(&self) -> bool {
!self.reversed()
}
}
impl<'a, H, G> ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
// Assign `expansion_degree` parents to `node` using an invertible function. That
// means we can't just generate random values between `[0, size())`, we need to
// expand the search space (domain) to accommodate every unique parent assignment
// generated here. This can be visualized more clearly as a matrix where the each
// new parent of each new node is assigned a unique `index`:
//
//
// | Parent 1 | Parent 2 | Parent 3 |
//
// | Node 1 | 0 | 1 | 2 |
//
// | Node 2 | 3 | 4 | 5 |
//
// | Node 3 | 6 | 7 | 8 |
//
// | Node 4 | 9 | A | B |
//
// This starting `index` will be shuffled to another position to generate a
// parent-child relationship, e.g., if generating the parents for the second node,
// `permute` would be called with values `[3; 4; 5]` that would be mapped to other
// indexes in the search space of `[0, B]`, say, values `[A; 0; 4]`, that would
// correspond to nodes numbered `[4; 1, 2]` which will become the parents of the
// second node. In a later pass invalid parents like 2, self-referencing, and parents
// with indexes bigger than 2 (if in the `forward` direction, smaller than 2 if the
// inverse), will be removed.
//
// Since `permute` is a bijective function which has the inverse `invert_permute`,
// it is guaranteed that when looking for the parents in the `reversed` direction
// the child `node` used earlier will now actually be the parent of the output
// parents generated before (inverting the relationship). Following the example,
// in the reverse direction, when looking for the parents of, say, node 1,
// `invert_permute` (that maps back the output of `permute` to its input) would
// receive the indexes `[0; 1; 2]`, where the index `0` is guaranteed to map back
// to the index `4` that generated it earlier, corresponding to the node 2, inverting
// in fact the child-parent relationship.
fn correspondent(&self, node: usize, i: usize) -> usize {
let a = (node * self.expansion_degree) as feistel::Index + i as feistel::Index;
let feistel_keys = &[1, 2, 3, 4];
let transformed = if self.reversed {
feistel::invert_permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
} else {
feistel::permute(
self.size() as feistel::Index * self.expansion_degree as feistel::Index,
a,
feistel_keys,
self.feistel_precomputed,
)
};
transformed as usize / self.expansion_degree
// Collapse the output in the matrix search space to the row of the corresponding
// node (losing the column information, that will be regenerated later when calling
// back this function in the `reversed` direction).
}
// Read the `node` entry in the parents cache (which may not exist) for
// the current direction set in the graph and return a copy of it (or
// `None` to signal a cache miss).
fn contains_parents_cache(&self, node: usize) -> bool {
if self.use_cache {
if let Some(ref cache) = PARENT_CACHE.read().unwrap().get(&self.id) {
if self.forward() {
cache.contains_forward(node as u32)
} else {
cache.contains_reverse(node as u32)
}
} else {
false
}
} else {
false
}
}
fn generate_expanded_parents(&self, node: usize) -> Vec<u32> {
(0..self.expansion_degree)
.filter_map(|i| {
let other = self.correspondent(node, i);
if self.reversed {
if other > node {
Some(other as u32)
} else {
None
}
} else if other < node {
Some(other as u32)
} else {
None
}
})
.collect()
}
}
impl<'a, H, G> ZigZag for ZigZagGraph<H, G>
where
H: Hasher,
G: Graph<H> + ParameterSetMetadata,
{
type BaseHasher = H;
type BaseGraph = G;
fn new_zigzag(
nodes: usize,
base_degree: usize,
expansion_degree: usize,
seed: [u32; 7],
) -> Self {
Self::new(None, nodes, base_degree, expansion_degree, seed)
}
/// To zigzag a graph, we just toggle its reversed field.
/// All the real work happens when we calculate node parents on-demand.
// We always share the two caches (forward/reversed) between
// ZigZag graphs even if each graph will use only one of those
// caches (depending of its direction). This allows to propagate
// the caches across different layers, where consecutive even+odd
// layers have inverse directions.
fn zigzag(&self) -> Self {
let mut zigzag = self.clone();
zigzag.reversed = !zigzag.reversed;
zigzag
}
fn base_graph(&self) -> Self::BaseGraph {
self.base_graph.clone()
}
fn expansion_degree(&self) -> usize {
self.expansion_degree
}
fn reversed(&self) -> bool {
self.reversed
}
// TODO: Optimization: Evaluate providing an `all_parents` (and hence
// `all_expanded_parents`) method that would return the entire cache
// in a single lock operation, or at least (if the cache is not big enough)
// it would allow to batch parents calculations with that single lock. Also,
// since there is a reciprocity between forward and reversed parents,
// we would only need to compute the parents in one direction and with
// that fill both caches.
#[inline]
fn expanded_parents<F, T>(&self, node: usize, mut cb: F) -> T
where | random_line_split | ||
converter.py | return binding
class Paint:
def __init__(self, cs, value):
self.cs = cs
self.value = value
def draw(self):
return self.cs.getRGB(*self.value)
class TextState(PDFTextState):
def __init__(self):
super().__init__()
self.fill = None
self.extState = {}
def copy(self):
obj = self.__class__()
obj.font = self.font
obj.fontsize = self.fontsize
obj.charspace = self.charspace
obj.wordspace = self.wordspace
obj.scaling = self.scaling
obj.leading = self.leading
obj.render = self.render
obj.rise = self.rise
obj.matrix = self.matrix
obj.linematrix = self.linematrix
obj.fill = self.fill
obj.extState = self.extState
return obj
def __setattr__(self, key, value):
if key in ['charspace', 'wordspace']:
value *= getattr(self, 'scaling', 100) * 0.01
return object.__setattr__(self, key, value)
class GraphicState(PDFGraphicState):
def __init__(self):
super().__init__()
self.stroke = self.fill = None
self.extState = {}
def copy(self):
obj = self.__class__()
obj.linewidth = self.linewidth
obj.linecap = self.linecap
obj.linejoin = self.linejoin
obj.miterlimit = self.miterlimit
obj.dash = self.dash
obj.intent = self.intent
obj.flatness = self.flatness
obj.stroke = self.stroke
obj.fill = self.fill
obj.extState = self.extState
return obj
class Device(PDFDevice):
def __init__(self, filtered=None, laparams=None, check_visible=True):
super().__init__(None)
self.filtered = filtered or []
self.check_visible = check_visible
self.analyzer = TextAnalyzer(**(laparams or {}))
self.pageno = 1
self.reset()
self.viewBox = [0, 0, 0, 0]
def reset(self):
self.images = {}
self.text_layer = []
self.layers = {}
self.layer_stack = []
def begin_page(self, page, ctm):
self.reset()
self.layers[LIT('Page')] = (page.cropbox, ctm)
self.layer_stack = [LIT('Page')]
self.viewBox = page.cropbox
self.ymax = page.mediabox[3] - page.mediabox[1]
def is_visible(self, span, bbox):
boxset = set(map(lambda p: (int(p[0]), int(p[1])), span.bbox))
if len(boxset) < len(span.bbox):
return False
xmin, ymin, xmax, ymax = bbox
return all(xmin < x < xmax and ymin < y < ymax for x, y in boxset)
def get_current_layer(self):
i = -1
depth = 0
while True:
layerName = self.layer_stack[i]
if layerName == 'end':
depth += 1
else:
depth -= 1
if depth < 0:
break
i -= 1
return layerName, self.layers[layerName]
def end_page(self, page):
self.text_layer = filter(lambda x: not self.check_visible
or self.is_visible(x, self.viewBox), self.text_layer)
lines = self.analyzer.group_lines(self.text_layer)
paras = self.analyzer.group_paras(lines)
self.text_layer = paras
self.pageno += 1
def begin_figure(self, name, bbox, matrix):
x, y, w, h = bbox
self.layers[name] = ([x, y, x+w, y+h], matrix)
self.layer_stack.append(name)
def end_figure(self, name):
self.layer_stack.append('end')
@render_type('path')
def paint_path(self, graphicstate, stroke, fill, evenodd, path):
# path handling suspended
return path
@render_type('image')
def render_image(self, name, stream, anchored=False, textstate=None):
bbox, matrix = self.get_current_layer()[1]
self.images.setdefault(stream.objid, (name, stream, bbox, matrix))
@render_type('text')
def render_string(self, textstate, seq, *args):
layerName = self.get_current_layer()[0]
x, y = textstate.linematrix
a, b, c, d, e, f = mult_matrix(textstate.matrix, self.ctm)
matrix = a, b, c, d, e, self.ymax - f
box = textSpanBox((x, y), seq, textstate, layerName=layerName, matrix=matrix)
# check if text is visible
if not textstate.extState.get('OP', False) or not textstate.extState.get('OPM', 0):
self.text_layer.append(box)
elif textstate.extState.get('OPM', 1) and any(textstate.fill.value):
self.text_layer.append(box)
textstate.linematrix = box.originbox[2]
class ResourceManager(PDFResourceManager):
def __init__(self):
self.fonts = {}
self.colorspaces = colorspace.defaults.copy()
self.xobjects = {}
self.cache = {}
self.stream_objects = []
def clear(self):
for res in self.fonts:
stream_to_close = getattr(res, 'embedFont', None)
stream_to_close and stream_to_close.close()
self.fonts.clear()
self.colorspaces.clear()
self.xobjects.clear()
def render_resource(self, res_type, res_obj):
|
@get_default('font')
def get_font(self, objid, obj=None):
for (fontid, spec) in dict_value(obj).items():
spec = dict_value(spec)
spec, fontType, embedFont, opentype = pdffonts.getType(spec)
if fontType:
font = fontType(spec, embedFont=embedFont and self.xobjects.get(
embedFont.objid, embedFont), opentype=opentype)
if embedFont:
objid = literal(embedFont.objid)
if not objid in self.xobjects:
self.xobjects[objid] = font.embedFont
self.fonts[literal(fontid)] = font
@get_default('colorspace')
def get_colorspace(self, objid, obj=None):
for (csid, spec) in dict_value(obj).items():
cs = colorspace.parse(spec)
if cs:
self.colorspaces[literal(csid)] = cs
def get_procset(self, objid, obj=None):
# procset handling suspended
pass
@get_default('xobject')
def get_xobject(self, objid, obj=None):
for (xobjid, xobjstrm) in dict_value(obj).items():
self.xobjects[literal(xobjid)] = xobjstrm
class Interpreter(PDFPageInterpreter):
def __init__(self, device):
self.rsrcmgr = ResourceManager()
self.device = device
# custom logging here
def log(self, message):
pass
def dup(self):
return self.__class__(self.device)
def close(self):
self.rsrcmgr.clear()
def init_resources(self, resources):
self.resources = resources
if resources:
for (k, v) in dict_value(resources).items():
self.debug and self.log('Resource: %r: %r' % (k, v))
self.rsrcmgr.render_resource(k, v)
def init_state(self, ctm):
self.gstack = []
self.ctm = ctm
self.device.set_ctm(self.ctm)
self.textstate = TextState()
self.graphicstate = GraphicState()
self.curpath = []
self.argstack = []
self.scs = self.ncs = colorspace.CMYKColorSpace()
def do_CS(self, name):
self.scs = self.rsrcmgr.get_colorspace(literal(name))
def do_cs(self, name):
self.ncs = self.rsrcmgr.get_colorspace(literal(name))
def do_SCN(self):
n = len(self.scs.mode)
pattern = self.argstack[-n:]
self.graphicstate.stroke = Paint(self.scs, pattern)
self.argstack = self.argstack[:-n]
def do_scn(self):
n = len(self.ncs.mode)
pattern = self.argstack[-n:]
self.graphicstate.fill = self.textstate.fill = Paint(self.ncs, pattern)
self.argstack = self.argstack[:-n]
def do_G(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.stroke = Paint(cs, gray)
def do_g(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, gray)
def do_RG(self, r, g, b):
cs = colorspace.RGBColorSpace | get_function = getattr(self, 'get_' + res_type.lower(), None)
return get_function and get_function(None, obj=res_obj) | identifier_body |
converter.py | ('Page')]
self.viewBox = page.cropbox
self.ymax = page.mediabox[3] - page.mediabox[1]
def is_visible(self, span, bbox):
boxset = set(map(lambda p: (int(p[0]), int(p[1])), span.bbox))
if len(boxset) < len(span.bbox):
return False
xmin, ymin, xmax, ymax = bbox
return all(xmin < x < xmax and ymin < y < ymax for x, y in boxset)
def get_current_layer(self):
i = -1
depth = 0
while True:
layerName = self.layer_stack[i]
if layerName == 'end':
depth += 1
else:
depth -= 1
if depth < 0:
break
i -= 1
return layerName, self.layers[layerName]
def end_page(self, page):
self.text_layer = filter(lambda x: not self.check_visible
or self.is_visible(x, self.viewBox), self.text_layer)
lines = self.analyzer.group_lines(self.text_layer)
paras = self.analyzer.group_paras(lines)
self.text_layer = paras
self.pageno += 1
def begin_figure(self, name, bbox, matrix):
x, y, w, h = bbox
self.layers[name] = ([x, y, x+w, y+h], matrix)
self.layer_stack.append(name)
def end_figure(self, name):
self.layer_stack.append('end')
@render_type('path')
def paint_path(self, graphicstate, stroke, fill, evenodd, path):
# path handling suspended
return path
@render_type('image')
def render_image(self, name, stream, anchored=False, textstate=None):
bbox, matrix = self.get_current_layer()[1]
self.images.setdefault(stream.objid, (name, stream, bbox, matrix))
@render_type('text')
def render_string(self, textstate, seq, *args):
layerName = self.get_current_layer()[0]
x, y = textstate.linematrix
a, b, c, d, e, f = mult_matrix(textstate.matrix, self.ctm)
matrix = a, b, c, d, e, self.ymax - f
box = textSpanBox((x, y), seq, textstate, layerName=layerName, matrix=matrix)
# check if text is visible
if not textstate.extState.get('OP', False) or not textstate.extState.get('OPM', 0):
self.text_layer.append(box)
elif textstate.extState.get('OPM', 1) and any(textstate.fill.value):
self.text_layer.append(box)
textstate.linematrix = box.originbox[2]
class ResourceManager(PDFResourceManager):
def __init__(self):
self.fonts = {}
self.colorspaces = colorspace.defaults.copy()
self.xobjects = {}
self.cache = {}
self.stream_objects = []
def clear(self):
for res in self.fonts:
stream_to_close = getattr(res, 'embedFont', None)
stream_to_close and stream_to_close.close()
self.fonts.clear()
self.colorspaces.clear()
self.xobjects.clear()
def render_resource(self, res_type, res_obj):
get_function = getattr(self, 'get_' + res_type.lower(), None)
return get_function and get_function(None, obj=res_obj)
@get_default('font')
def get_font(self, objid, obj=None):
for (fontid, spec) in dict_value(obj).items():
spec = dict_value(spec)
spec, fontType, embedFont, opentype = pdffonts.getType(spec)
if fontType:
font = fontType(spec, embedFont=embedFont and self.xobjects.get(
embedFont.objid, embedFont), opentype=opentype)
if embedFont:
objid = literal(embedFont.objid)
if not objid in self.xobjects:
self.xobjects[objid] = font.embedFont
self.fonts[literal(fontid)] = font
@get_default('colorspace')
def get_colorspace(self, objid, obj=None):
for (csid, spec) in dict_value(obj).items():
cs = colorspace.parse(spec)
if cs:
self.colorspaces[literal(csid)] = cs
def get_procset(self, objid, obj=None):
# procset handling suspended
pass
@get_default('xobject')
def get_xobject(self, objid, obj=None):
for (xobjid, xobjstrm) in dict_value(obj).items():
self.xobjects[literal(xobjid)] = xobjstrm
class Interpreter(PDFPageInterpreter):
def __init__(self, device):
self.rsrcmgr = ResourceManager()
self.device = device
# custom logging here
def log(self, message):
pass
def dup(self):
return self.__class__(self.device)
def close(self):
self.rsrcmgr.clear()
def init_resources(self, resources):
self.resources = resources
if resources:
for (k, v) in dict_value(resources).items():
self.debug and self.log('Resource: %r: %r' % (k, v))
self.rsrcmgr.render_resource(k, v)
def init_state(self, ctm):
self.gstack = []
self.ctm = ctm
self.device.set_ctm(self.ctm)
self.textstate = TextState()
self.graphicstate = GraphicState()
self.curpath = []
self.argstack = []
self.scs = self.ncs = colorspace.CMYKColorSpace()
def do_CS(self, name):
self.scs = self.rsrcmgr.get_colorspace(literal(name))
def do_cs(self, name):
self.ncs = self.rsrcmgr.get_colorspace(literal(name))
def do_SCN(self):
n = len(self.scs.mode)
pattern = self.argstack[-n:]
self.graphicstate.stroke = Paint(self.scs, pattern)
self.argstack = self.argstack[:-n]
def do_scn(self):
n = len(self.ncs.mode)
pattern = self.argstack[-n:]
self.graphicstate.fill = self.textstate.fill = Paint(self.ncs, pattern)
self.argstack = self.argstack[:-n]
def do_G(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.stroke = Paint(cs, gray)
def do_g(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, gray)
def do_RG(self, r, g, b):
cs = colorspace.RGBColorSpace()
self.graphicstate.stroke = Paint(cs, (r, g, b))
def do_rg(self, r, g, b):
cs = colorspace.RGBColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, (r, g, b))
def do_K(self, c, m, y, k):
cs = colorspace.CMYKColorSpace()
self.graphicstate.stroke = Paint(cs, (c, m, y, k))
def do_k(self, c, m, y, k):
cs = colorspace.CMYKColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, (c, m, y, k))
def do_Tf(self, fontid, fontsize):
self.textstate.font = self.rsrcmgr.get_font(literal(fontid))
self.textstate.fontsize = fontsize
def do_Do(self, xobjid):
xobj = self.rsrcmgr.get_xobject(literal(xobjid))
if not xobj:
return
self.debug and self.log('Processing xobj: %r' % xobj)
xobj = stream_value(xobj)
subtype = xobj.get('Subtype')
if subtype is LIT('Form') and 'BBox' in xobj:
interpreter = self.dup()
bbox = list_value(xobj['BBox'])
matrix = list_value(xobj.get('Matrix', (1, 0, 0, 1, 0, 0)))
# According to PDF reference 1.7 section 4.9.1, XObjects in
# earlier PDFs (prior to v1.2) use the page's Resources entry
# instead of having their own Resources entry.
resources = dict_value(xobj.get('Resources')
) or self.resources.copy()
self.device.begin_figure(xobjid, bbox, matrix)
interpreter.render_contents(
resources, [xobj], ctm=mult_matrix(matrix, self.ctm))
self.device.end_figure(xobjid)
elif subtype is LIT('Image') and 'Width' in xobj and 'Height' in xobj:
self.device.render_image(xobjid, xobj, anchored=True)
else:
# unsupported xobject type.
pass
def do_EI(self, obj):
if 'W' in obj and 'H' in obj:
self.device.render_image(
str(id(obj)), obj, anchored=False, state=self.textstate)
def | do_gs | identifier_name | |
converter.py | return binding
class Paint:
def __init__(self, cs, value):
self.cs = cs
self.value = value
def draw(self):
return self.cs.getRGB(*self.value)
class TextState(PDFTextState):
def __init__(self):
super().__init__()
self.fill = None
self.extState = {}
def copy(self):
obj = self.__class__()
obj.font = self.font
obj.fontsize = self.fontsize
obj.charspace = self.charspace
obj.wordspace = self.wordspace
obj.scaling = self.scaling
obj.leading = self.leading
obj.render = self.render
obj.rise = self.rise
obj.matrix = self.matrix
obj.linematrix = self.linematrix
obj.fill = self.fill
obj.extState = self.extState
return obj
def __setattr__(self, key, value):
if key in ['charspace', 'wordspace']:
value *= getattr(self, 'scaling', 100) * 0.01
return object.__setattr__(self, key, value)
class GraphicState(PDFGraphicState):
def __init__(self):
super().__init__()
self.stroke = self.fill = None
self.extState = {}
def copy(self):
obj = self.__class__()
obj.linewidth = self.linewidth
obj.linecap = self.linecap
obj.linejoin = self.linejoin
obj.miterlimit = self.miterlimit
obj.dash = self.dash
obj.intent = self.intent
obj.flatness = self.flatness
obj.stroke = self.stroke
obj.fill = self.fill
obj.extState = self.extState
return obj
class Device(PDFDevice):
def __init__(self, filtered=None, laparams=None, check_visible=True):
super().__init__(None)
self.filtered = filtered or []
self.check_visible = check_visible
self.analyzer = TextAnalyzer(**(laparams or {}))
self.pageno = 1
self.reset()
self.viewBox = [0, 0, 0, 0]
def reset(self):
self.images = {}
self.text_layer = []
self.layers = {}
self.layer_stack = []
def begin_page(self, page, ctm):
self.reset()
self.layers[LIT('Page')] = (page.cropbox, ctm)
self.layer_stack = [LIT('Page')]
self.viewBox = page.cropbox
self.ymax = page.mediabox[3] - page.mediabox[1]
def is_visible(self, span, bbox):
boxset = set(map(lambda p: (int(p[0]), int(p[1])), span.bbox))
if len(boxset) < len(span.bbox):
return False
xmin, ymin, xmax, ymax = bbox
return all(xmin < x < xmax and ymin < y < ymax for x, y in boxset)
def get_current_layer(self):
i = -1
depth = 0
while True:
layerName = self.layer_stack[i]
if layerName == 'end':
depth += 1
else:
depth -= 1
if depth < 0:
break
i -= 1
return layerName, self.layers[layerName]
def end_page(self, page):
self.text_layer = filter(lambda x: not self.check_visible
or self.is_visible(x, self.viewBox), self.text_layer)
lines = self.analyzer.group_lines(self.text_layer)
paras = self.analyzer.group_paras(lines)
self.text_layer = paras
self.pageno += 1
def begin_figure(self, name, bbox, matrix):
x, y, w, h = bbox
self.layers[name] = ([x, y, x+w, y+h], matrix)
self.layer_stack.append(name)
def end_figure(self, name):
self.layer_stack.append('end')
@render_type('path')
def paint_path(self, graphicstate, stroke, fill, evenodd, path):
# path handling suspended
return path
@render_type('image')
def render_image(self, name, stream, anchored=False, textstate=None):
bbox, matrix = self.get_current_layer()[1]
self.images.setdefault(stream.objid, (name, stream, bbox, matrix))
@render_type('text')
def render_string(self, textstate, seq, *args):
layerName = self.get_current_layer()[0]
x, y = textstate.linematrix
a, b, c, d, e, f = mult_matrix(textstate.matrix, self.ctm)
matrix = a, b, c, d, e, self.ymax - f
box = textSpanBox((x, y), seq, textstate, layerName=layerName, matrix=matrix)
# check if text is visible
if not textstate.extState.get('OP', False) or not textstate.extState.get('OPM', 0):
self.text_layer.append(box)
elif textstate.extState.get('OPM', 1) and any(textstate.fill.value):
self.text_layer.append(box)
textstate.linematrix = box.originbox[2]
class ResourceManager(PDFResourceManager):
def __init__(self):
self.fonts = {}
self.colorspaces = colorspace.defaults.copy()
self.xobjects = {}
self.cache = {}
self.stream_objects = []
def clear(self):
for res in self.fonts:
stream_to_close = getattr(res, 'embedFont', None)
stream_to_close and stream_to_close.close()
self.fonts.clear()
self.colorspaces.clear()
self.xobjects.clear()
def render_resource(self, res_type, res_obj):
get_function = getattr(self, 'get_' + res_type.lower(), None)
return get_function and get_function(None, obj=res_obj)
@get_default('font')
def get_font(self, objid, obj=None):
for (fontid, spec) in dict_value(obj).items():
spec = dict_value(spec)
spec, fontType, embedFont, opentype = pdffonts.getType(spec)
if fontType:
font = fontType(spec, embedFont=embedFont and self.xobjects.get(
embedFont.objid, embedFont), opentype=opentype)
if embedFont:
objid = literal(embedFont.objid)
if not objid in self.xobjects:
|
self.fonts[literal(fontid)] = font
@get_default('colorspace')
def get_colorspace(self, objid, obj=None):
for (csid, spec) in dict_value(obj).items():
cs = colorspace.parse(spec)
if cs:
self.colorspaces[literal(csid)] = cs
def get_procset(self, objid, obj=None):
# procset handling suspended
pass
@get_default('xobject')
def get_xobject(self, objid, obj=None):
for (xobjid, xobjstrm) in dict_value(obj).items():
self.xobjects[literal(xobjid)] = xobjstrm
class Interpreter(PDFPageInterpreter):
def __init__(self, device):
self.rsrcmgr = ResourceManager()
self.device = device
# custom logging here
def log(self, message):
pass
def dup(self):
return self.__class__(self.device)
def close(self):
self.rsrcmgr.clear()
def init_resources(self, resources):
self.resources = resources
if resources:
for (k, v) in dict_value(resources).items():
self.debug and self.log('Resource: %r: %r' % (k, v))
self.rsrcmgr.render_resource(k, v)
def init_state(self, ctm):
self.gstack = []
self.ctm = ctm
self.device.set_ctm(self.ctm)
self.textstate = TextState()
self.graphicstate = GraphicState()
self.curpath = []
self.argstack = []
self.scs = self.ncs = colorspace.CMYKColorSpace()
def do_CS(self, name):
self.scs = self.rsrcmgr.get_colorspace(literal(name))
def do_cs(self, name):
self.ncs = self.rsrcmgr.get_colorspace(literal(name))
def do_SCN(self):
n = len(self.scs.mode)
pattern = self.argstack[-n:]
self.graphicstate.stroke = Paint(self.scs, pattern)
self.argstack = self.argstack[:-n]
def do_scn(self):
n = len(self.ncs.mode)
pattern = self.argstack[-n:]
self.graphicstate.fill = self.textstate.fill = Paint(self.ncs, pattern)
self.argstack = self.argstack[:-n]
def do_G(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.stroke = Paint(cs, gray)
def do_g(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, gray)
def do_RG(self, r, g, b):
cs = colorspace.RGBColorSpace()
| self.xobjects[objid] = font.embedFont | conditional_block |
converter.py | return False
xmin, ymin, xmax, ymax = bbox
return all(xmin < x < xmax and ymin < y < ymax for x, y in boxset)
def get_current_layer(self):
i = -1
depth = 0
while True:
layerName = self.layer_stack[i]
if layerName == 'end':
depth += 1
else:
depth -= 1
if depth < 0:
break
i -= 1
return layerName, self.layers[layerName]
def end_page(self, page):
self.text_layer = filter(lambda x: not self.check_visible
or self.is_visible(x, self.viewBox), self.text_layer)
lines = self.analyzer.group_lines(self.text_layer)
paras = self.analyzer.group_paras(lines)
self.text_layer = paras
self.pageno += 1
def begin_figure(self, name, bbox, matrix):
x, y, w, h = bbox
self.layers[name] = ([x, y, x+w, y+h], matrix)
self.layer_stack.append(name)
def end_figure(self, name):
self.layer_stack.append('end')
@render_type('path')
def paint_path(self, graphicstate, stroke, fill, evenodd, path):
# path handling suspended
return path
@render_type('image')
def render_image(self, name, stream, anchored=False, textstate=None):
bbox, matrix = self.get_current_layer()[1]
self.images.setdefault(stream.objid, (name, stream, bbox, matrix))
@render_type('text')
def render_string(self, textstate, seq, *args):
layerName = self.get_current_layer()[0]
x, y = textstate.linematrix
a, b, c, d, e, f = mult_matrix(textstate.matrix, self.ctm)
matrix = a, b, c, d, e, self.ymax - f
box = textSpanBox((x, y), seq, textstate, layerName=layerName, matrix=matrix)
# check if text is visible
if not textstate.extState.get('OP', False) or not textstate.extState.get('OPM', 0):
self.text_layer.append(box)
elif textstate.extState.get('OPM', 1) and any(textstate.fill.value):
self.text_layer.append(box)
textstate.linematrix = box.originbox[2]
class ResourceManager(PDFResourceManager):
def __init__(self):
self.fonts = {}
self.colorspaces = colorspace.defaults.copy()
self.xobjects = {}
self.cache = {}
self.stream_objects = []
def clear(self):
for res in self.fonts:
stream_to_close = getattr(res, 'embedFont', None)
stream_to_close and stream_to_close.close()
self.fonts.clear()
self.colorspaces.clear()
self.xobjects.clear()
def render_resource(self, res_type, res_obj):
get_function = getattr(self, 'get_' + res_type.lower(), None)
return get_function and get_function(None, obj=res_obj)
@get_default('font')
def get_font(self, objid, obj=None):
for (fontid, spec) in dict_value(obj).items():
spec = dict_value(spec)
spec, fontType, embedFont, opentype = pdffonts.getType(spec)
if fontType:
font = fontType(spec, embedFont=embedFont and self.xobjects.get(
embedFont.objid, embedFont), opentype=opentype)
if embedFont:
objid = literal(embedFont.objid)
if not objid in self.xobjects:
self.xobjects[objid] = font.embedFont
self.fonts[literal(fontid)] = font
@get_default('colorspace')
def get_colorspace(self, objid, obj=None):
for (csid, spec) in dict_value(obj).items():
cs = colorspace.parse(spec)
if cs:
self.colorspaces[literal(csid)] = cs
def get_procset(self, objid, obj=None):
# procset handling suspended
pass
@get_default('xobject')
def get_xobject(self, objid, obj=None):
for (xobjid, xobjstrm) in dict_value(obj).items():
self.xobjects[literal(xobjid)] = xobjstrm
class Interpreter(PDFPageInterpreter):
def __init__(self, device):
self.rsrcmgr = ResourceManager()
self.device = device
# custom logging here
def log(self, message):
pass
def dup(self):
return self.__class__(self.device)
def close(self):
self.rsrcmgr.clear()
def init_resources(self, resources):
self.resources = resources
if resources:
for (k, v) in dict_value(resources).items():
self.debug and self.log('Resource: %r: %r' % (k, v))
self.rsrcmgr.render_resource(k, v)
def init_state(self, ctm):
self.gstack = []
self.ctm = ctm
self.device.set_ctm(self.ctm)
self.textstate = TextState()
self.graphicstate = GraphicState()
self.curpath = []
self.argstack = []
self.scs = self.ncs = colorspace.CMYKColorSpace()
def do_CS(self, name):
self.scs = self.rsrcmgr.get_colorspace(literal(name))
def do_cs(self, name):
self.ncs = self.rsrcmgr.get_colorspace(literal(name))
def do_SCN(self):
n = len(self.scs.mode)
pattern = self.argstack[-n:]
self.graphicstate.stroke = Paint(self.scs, pattern)
self.argstack = self.argstack[:-n]
def do_scn(self):
n = len(self.ncs.mode)
pattern = self.argstack[-n:]
self.graphicstate.fill = self.textstate.fill = Paint(self.ncs, pattern)
self.argstack = self.argstack[:-n]
def do_G(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.stroke = Paint(cs, gray)
def do_g(self, gray):
cs = colorspace.GrayColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, gray)
def do_RG(self, r, g, b):
cs = colorspace.RGBColorSpace()
self.graphicstate.stroke = Paint(cs, (r, g, b))
def do_rg(self, r, g, b):
cs = colorspace.RGBColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, (r, g, b))
def do_K(self, c, m, y, k):
cs = colorspace.CMYKColorSpace()
self.graphicstate.stroke = Paint(cs, (c, m, y, k))
def do_k(self, c, m, y, k):
cs = colorspace.CMYKColorSpace()
self.graphicstate.fill = self.textstate.fill = Paint(cs, (c, m, y, k))
def do_Tf(self, fontid, fontsize):
self.textstate.font = self.rsrcmgr.get_font(literal(fontid))
self.textstate.fontsize = fontsize
def do_Do(self, xobjid):
xobj = self.rsrcmgr.get_xobject(literal(xobjid))
if not xobj:
return
self.debug and self.log('Processing xobj: %r' % xobj)
xobj = stream_value(xobj)
subtype = xobj.get('Subtype')
if subtype is LIT('Form') and 'BBox' in xobj:
interpreter = self.dup()
bbox = list_value(xobj['BBox'])
matrix = list_value(xobj.get('Matrix', (1, 0, 0, 1, 0, 0)))
# According to PDF reference 1.7 section 4.9.1, XObjects in
# earlier PDFs (prior to v1.2) use the page's Resources entry
# instead of having their own Resources entry.
resources = dict_value(xobj.get('Resources')
) or self.resources.copy()
self.device.begin_figure(xobjid, bbox, matrix)
interpreter.render_contents(
resources, [xobj], ctm=mult_matrix(matrix, self.ctm))
self.device.end_figure(xobjid)
elif subtype is LIT('Image') and 'Width' in xobj and 'Height' in xobj:
self.device.render_image(xobjid, xobj, anchored=True)
else:
# unsupported xobject type.
pass
def do_EI(self, obj):
if 'W' in obj and 'H' in obj:
self.device.render_image(
str(id(obj)), obj, anchored=False, state=self.textstate)
def do_gs(self, name):
if isinstance(name, PSLiteral):
name = name.name
gstate = self.resources['ExtGState'].get(name)
if gstate and not self.textstate.extState:
gstate = resolve1(gstate)
self.textstate.extState = gstate
def do_q(self):
self.gstack.append(self.get_current_state()) | random_line_split | ||
diagnostic_server.rs | ProcessBuilder;
use serde::{Deserialize, Serialize};
use tracing::warn;
use crate::core::Edition;
use crate::util::errors::CargoResult;
use crate::util::Config;
const DIAGNOSTICS_SERVER_VAR: &str = "__CARGO_FIX_DIAGNOSTICS_SERVER";
#[derive(Deserialize, Serialize, Hash, Eq, PartialEq, Clone)]
pub enum Message {
Migrating {
file: String,
from_edition: Edition,
to_edition: Edition,
},
Fixing {
file: String,
},
Fixed {
file: String,
fixes: u32,
},
FixFailed {
files: Vec<String>,
krate: Option<String>,
errors: Vec<String>,
abnormal_exit: Option<String>,
},
ReplaceFailed {
file: String,
message: String,
},
EditionAlreadyEnabled {
message: String,
edition: Edition,
},
}
impl Message {
pub fn post(&self, config: &Config) -> Result<(), Error> {
let addr = config
.get_env(DIAGNOSTICS_SERVER_VAR)
.context("diagnostics collector misconfigured")?;
let mut client =
TcpStream::connect(&addr).context("failed to connect to parent diagnostics target")?;
let s = serde_json::to_string(self).context("failed to serialize message")?;
client
.write_all(s.as_bytes())
.context("failed to write message to diagnostics target")?;
client
.shutdown(Shutdown::Write)
.context("failed to shutdown")?;
client
.read_to_end(&mut Vec::new())
.context("failed to receive a disconnect")?;
Ok(())
}
}
/// A printer that will print diagnostics messages to the shell.
pub struct DiagnosticPrinter<'a> {
/// The config to get the shell to print to.
config: &'a Config,
/// An optional wrapper to be used in addition to `rustc.wrapper` for workspace crates.
/// This is used to get the correct bug report URL. For instance,
/// if `clippy-driver` is set as the value for the wrapper,
/// then the correct bug report URL for `clippy` can be obtained.
workspace_wrapper: &'a Option<PathBuf>,
// A set of messages that have already been printed.
dedupe: HashSet<Message>,
}
impl<'a> DiagnosticPrinter<'a> {
pub fn new(
config: &'a Config,
workspace_wrapper: &'a Option<PathBuf>,
) -> DiagnosticPrinter<'a> {
DiagnosticPrinter {
config,
workspace_wrapper,
dedupe: HashSet::new(),
}
}
pub fn print(&mut self, msg: &Message) -> CargoResult<()> {
match msg {
Message::Migrating {
file,
from_edition,
to_edition,
} => {
if !self.dedupe.insert(msg.clone()) {
return Ok(());
}
self.config.shell().status(
"Migrating",
&format!("{} from {} edition to {}", file, from_edition, to_edition),
)
}
Message::Fixing { file } => self
.config
.shell()
.verbose(|shell| shell.status("Fixing", file)),
Message::Fixed { file, fixes } => {
let msg = if *fixes == 1 { "fix" } else { "fixes" };
let msg = format!("{} ({} {})", file, fixes, msg);
self.config.shell().status("Fixed", msg)
}
Message::ReplaceFailed { file, message } => {
let msg = format!("error applying suggestions to `{}`\n", file);
self.config.shell().warn(&msg)?;
write!(
self.config.shell().err(),
"The full error message was:\n\n> {}\n\n",
message,
)?;
let issue_link = get_bug_report_url(self.workspace_wrapper);
write!(
self.config.shell().err(),
"{}",
gen_please_report_this_bug_text(issue_link)
)?;
Ok(())
}
Message::FixFailed {
files,
krate,
errors,
abnormal_exit,
} => {
if let Some(ref krate) = *krate {
self.config.shell().warn(&format!(
"failed to automatically apply fixes suggested by rustc \
to crate `{}`",
krate,
))?;
} else {
self.config
.shell()
.warn("failed to automatically apply fixes suggested by rustc")?;
}
if !files.is_empty() {
writeln!(
self.config.shell().err(),
"\nafter fixes were automatically applied the compiler \
reported errors within these files:\n"
)?;
for file in files {
writeln!(self.config.shell().err(), " * {}", file)?;
}
writeln!(self.config.shell().err())?;
}
let issue_link = get_bug_report_url(self.workspace_wrapper);
write!(
self.config.shell().err(),
"{}",
gen_please_report_this_bug_text(issue_link)
)?;
if !errors.is_empty() {
writeln!(
self.config.shell().err(),
"The following errors were reported:"
)?;
for error in errors {
write!(self.config.shell().err(), "{}", error)?;
if !error.ends_with('\n') {
writeln!(self.config.shell().err())?;
}
}
}
if let Some(exit) = abnormal_exit {
writeln!(
self.config.shell().err(),
"rustc exited abnormally: {}",
exit
)?;
}
writeln!(
self.config.shell().err(),
"Original diagnostics will follow.\n"
)?;
Ok(())
}
Message::EditionAlreadyEnabled { message, edition } => {
if !self.dedupe.insert(msg.clone()) {
return Ok(());
}
// Don't give a really verbose warning if it has already been issued.
if self.dedupe.insert(Message::EditionAlreadyEnabled {
message: "".to_string(), // Dummy, so that this only long-warns once.
edition: *edition,
}) {
self.config.shell().warn(&format!("\
{}
If you are trying to migrate from the previous edition ({prev_edition}), the
process requires following these steps:
1. Start with `edition = \"{prev_edition}\"` in `Cargo.toml`
2. Run `cargo fix --edition`
3. Modify `Cargo.toml` to set `edition = \"{this_edition}\"`
4. Run `cargo build` or `cargo test` to verify the fixes worked
More details may be found at
https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
",
message, this_edition=edition, prev_edition=edition.previous().unwrap()
))
} else {
self.config.shell().warn(message)
}
}
}
}
}
fn gen_please_report_this_bug_text(url: &str) -> String {
format!(
"This likely indicates a bug in either rustc or cargo itself,\n\
and we would appreciate a bug report! You're likely to see \n\
a number of compiler warnings after this message which cargo\n\
attempted to fix but failed. If you could open an issue at\n\
{}\n\
quoting the full output of this command we'd be very appreciative!\n\
Note that you may be able to make some more progress in the near-term\n\
fixing code with the `--broken-code` flag\n\n\
",
url
)
}
fn get_bug_report_url(rustc_workspace_wrapper: &Option<PathBuf>) -> &str {
let clippy = std::ffi::OsStr::new("clippy-driver");
let issue_link = match rustc_workspace_wrapper.as_ref().and_then(|x| x.file_stem()) {
Some(wrapper) if wrapper == clippy => "https://github.com/rust-lang/rust-clippy/issues",
_ => "https://github.com/rust-lang/rust/issues",
};
issue_link
}
#[derive(Debug)]
pub struct | {
listener: TcpListener,
addr: SocketAddr,
}
pub struct StartedServer {
addr: SocketAddr,
done: Arc<AtomicBool>,
thread: Option<JoinHandle<()>>,
}
impl RustfixDiagnosticServer {
pub fn new() -> Result<Self, Error> {
let listener = TcpListener::bind("127.0.0.1:0")
.with_context(|| "failed to bind TCP listener to manage locking")?;
let addr = listener.local_addr()?;
Ok(RustfixDiagnosticServer { listener, addr })
}
pub fn configure(&self, process: &mut ProcessBuilder) {
process.env(DIAGNOSTICS_SERVER_VAR, self.addr.to_string());
}
pub fn start<F>(self, on_message: F) -> Result<StartedServer, Error>
where
F: Fn(Message) + Send + 'static,
{
let addr = self.addr;
let done = Arc::new(AtomicBool::new(false));
let done2 = done.clone();
let thread = thread::spawn(move || {
self.run(&on_message, &done2);
});
Ok(StartedServer {
addr,
thread: Some(thread),
done,
})
}
fn run(self, on_message: &dyn Fn(Message | RustfixDiagnosticServer | identifier_name |
diagnostic_server.rs | ProcessBuilder;
use serde::{Deserialize, Serialize};
use tracing::warn;
use crate::core::Edition;
use crate::util::errors::CargoResult;
use crate::util::Config;
const DIAGNOSTICS_SERVER_VAR: &str = "__CARGO_FIX_DIAGNOSTICS_SERVER";
#[derive(Deserialize, Serialize, Hash, Eq, PartialEq, Clone)]
pub enum Message {
Migrating {
file: String,
from_edition: Edition,
to_edition: Edition,
},
Fixing {
file: String,
},
Fixed {
file: String,
fixes: u32,
},
FixFailed {
files: Vec<String>,
krate: Option<String>,
errors: Vec<String>,
abnormal_exit: Option<String>,
},
ReplaceFailed {
file: String,
message: String,
},
EditionAlreadyEnabled {
message: String,
edition: Edition,
},
}
impl Message {
pub fn post(&self, config: &Config) -> Result<(), Error> {
let addr = config
.get_env(DIAGNOSTICS_SERVER_VAR)
.context("diagnostics collector misconfigured")?;
let mut client =
TcpStream::connect(&addr).context("failed to connect to parent diagnostics target")?;
let s = serde_json::to_string(self).context("failed to serialize message")?;
client
.write_all(s.as_bytes())
.context("failed to write message to diagnostics target")?;
client
.shutdown(Shutdown::Write)
.context("failed to shutdown")?;
client
.read_to_end(&mut Vec::new())
.context("failed to receive a disconnect")?;
Ok(())
}
}
/// A printer that will print diagnostics messages to the shell.
pub struct DiagnosticPrinter<'a> {
/// The config to get the shell to print to.
config: &'a Config,
/// An optional wrapper to be used in addition to `rustc.wrapper` for workspace crates.
/// This is used to get the correct bug report URL. For instance,
/// if `clippy-driver` is set as the value for the wrapper,
/// then the correct bug report URL for `clippy` can be obtained.
workspace_wrapper: &'a Option<PathBuf>,
// A set of messages that have already been printed.
dedupe: HashSet<Message>,
}
impl<'a> DiagnosticPrinter<'a> {
pub fn new(
config: &'a Config,
workspace_wrapper: &'a Option<PathBuf>,
) -> DiagnosticPrinter<'a> {
DiagnosticPrinter {
config,
workspace_wrapper,
dedupe: HashSet::new(),
}
}
pub fn print(&mut self, msg: &Message) -> CargoResult<()> {
match msg {
Message::Migrating {
file,
from_edition,
to_edition,
} => {
if !self.dedupe.insert(msg.clone()) {
return Ok(());
}
self.config.shell().status(
"Migrating",
&format!("{} from {} edition to {}", file, from_edition, to_edition),
)
}
Message::Fixing { file } => self
.config
.shell()
.verbose(|shell| shell.status("Fixing", file)),
Message::Fixed { file, fixes } => {
let msg = if *fixes == 1 { "fix" } else { "fixes" };
let msg = format!("{} ({} {})", file, fixes, msg);
self.config.shell().status("Fixed", msg)
}
Message::ReplaceFailed { file, message } => {
let msg = format!("error applying suggestions to `{}`\n", file);
self.config.shell().warn(&msg)?;
write!(
self.config.shell().err(),
"The full error message was:\n\n> {}\n\n",
message,
)?;
let issue_link = get_bug_report_url(self.workspace_wrapper);
write!(
self.config.shell().err(),
"{}",
gen_please_report_this_bug_text(issue_link)
)?;
Ok(())
}
Message::FixFailed {
files,
krate,
errors,
abnormal_exit,
} => {
if let Some(ref krate) = *krate {
self.config.shell().warn(&format!(
"failed to automatically apply fixes suggested by rustc \
to crate `{}`",
krate,
))?;
} else |
if !files.is_empty() {
writeln!(
self.config.shell().err(),
"\nafter fixes were automatically applied the compiler \
reported errors within these files:\n"
)?;
for file in files {
writeln!(self.config.shell().err(), " * {}", file)?;
}
writeln!(self.config.shell().err())?;
}
let issue_link = get_bug_report_url(self.workspace_wrapper);
write!(
self.config.shell().err(),
"{}",
gen_please_report_this_bug_text(issue_link)
)?;
if !errors.is_empty() {
writeln!(
self.config.shell().err(),
"The following errors were reported:"
)?;
for error in errors {
write!(self.config.shell().err(), "{}", error)?;
if !error.ends_with('\n') {
writeln!(self.config.shell().err())?;
}
}
}
if let Some(exit) = abnormal_exit {
writeln!(
self.config.shell().err(),
"rustc exited abnormally: {}",
exit
)?;
}
writeln!(
self.config.shell().err(),
"Original diagnostics will follow.\n"
)?;
Ok(())
}
Message::EditionAlreadyEnabled { message, edition } => {
if !self.dedupe.insert(msg.clone()) {
return Ok(());
}
// Don't give a really verbose warning if it has already been issued.
if self.dedupe.insert(Message::EditionAlreadyEnabled {
message: "".to_string(), // Dummy, so that this only long-warns once.
edition: *edition,
}) {
self.config.shell().warn(&format!("\
{}
If you are trying to migrate from the previous edition ({prev_edition}), the
process requires following these steps:
1. Start with `edition = \"{prev_edition}\"` in `Cargo.toml`
2. Run `cargo fix --edition`
3. Modify `Cargo.toml` to set `edition = \"{this_edition}\"`
4. Run `cargo build` or `cargo test` to verify the fixes worked
More details may be found at
https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
",
message, this_edition=edition, prev_edition=edition.previous().unwrap()
))
} else {
self.config.shell().warn(message)
}
}
}
}
}
fn gen_please_report_this_bug_text(url: &str) -> String {
format!(
"This likely indicates a bug in either rustc or cargo itself,\n\
and we would appreciate a bug report! You're likely to see \n\
a number of compiler warnings after this message which cargo\n\
attempted to fix but failed. If you could open an issue at\n\
{}\n\
quoting the full output of this command we'd be very appreciative!\n\
Note that you may be able to make some more progress in the near-term\n\
fixing code with the `--broken-code` flag\n\n\
",
url
)
}
fn get_bug_report_url(rustc_workspace_wrapper: &Option<PathBuf>) -> &str {
let clippy = std::ffi::OsStr::new("clippy-driver");
let issue_link = match rustc_workspace_wrapper.as_ref().and_then(|x| x.file_stem()) {
Some(wrapper) if wrapper == clippy => "https://github.com/rust-lang/rust-clippy/issues",
_ => "https://github.com/rust-lang/rust/issues",
};
issue_link
}
#[derive(Debug)]
pub struct RustfixDiagnosticServer {
listener: TcpListener,
addr: SocketAddr,
}
pub struct StartedServer {
addr: SocketAddr,
done: Arc<AtomicBool>,
thread: Option<JoinHandle<()>>,
}
impl RustfixDiagnosticServer {
pub fn new() -> Result<Self, Error> {
let listener = TcpListener::bind("127.0.0.1:0")
.with_context(|| "failed to bind TCP listener to manage locking")?;
let addr = listener.local_addr()?;
Ok(RustfixDiagnosticServer { listener, addr })
}
pub fn configure(&self, process: &mut ProcessBuilder) {
process.env(DIAGNOSTICS_SERVER_VAR, self.addr.to_string());
}
pub fn start<F>(self, on_message: F) -> Result<StartedServer, Error>
where
F: Fn(Message) + Send + 'static,
{
let addr = self.addr;
let done = Arc::new(AtomicBool::new(false));
let done2 = done.clone();
let thread = thread::spawn(move || {
self.run(&on_message, &done2);
});
Ok(StartedServer {
addr,
thread: Some(thread),
done,
})
}
fn run(self, on_message: &dyn Fn(Message | {
self.config
.shell()
.warn("failed to automatically apply fixes suggested by rustc")?;
} | conditional_block |
diagnostic_server.rs | ::ProcessBuilder;
use serde::{Deserialize, Serialize};
use tracing::warn;
use crate::core::Edition;
use crate::util::errors::CargoResult;
use crate::util::Config;
const DIAGNOSTICS_SERVER_VAR: &str = "__CARGO_FIX_DIAGNOSTICS_SERVER";
#[derive(Deserialize, Serialize, Hash, Eq, PartialEq, Clone)]
pub enum Message {
Migrating {
file: String,
from_edition: Edition,
to_edition: Edition,
},
Fixing {
file: String,
},
Fixed {
file: String,
fixes: u32,
},
FixFailed {
files: Vec<String>,
krate: Option<String>,
errors: Vec<String>,
abnormal_exit: Option<String>,
},
ReplaceFailed {
file: String,
message: String,
},
EditionAlreadyEnabled {
message: String,
edition: Edition,
},
}
impl Message {
pub fn post(&self, config: &Config) -> Result<(), Error> {
let addr = config
.get_env(DIAGNOSTICS_SERVER_VAR)
.context("diagnostics collector misconfigured")?;
let mut client =
TcpStream::connect(&addr).context("failed to connect to parent diagnostics target")?;
let s = serde_json::to_string(self).context("failed to serialize message")?;
client
.write_all(s.as_bytes())
.context("failed to write message to diagnostics target")?;
client
.shutdown(Shutdown::Write)
.context("failed to shutdown")?;
client
.read_to_end(&mut Vec::new())
.context("failed to receive a disconnect")?;
Ok(())
}
}
/// A printer that will print diagnostics messages to the shell.
pub struct DiagnosticPrinter<'a> {
/// The config to get the shell to print to.
config: &'a Config,
/// An optional wrapper to be used in addition to `rustc.wrapper` for workspace crates.
/// This is used to get the correct bug report URL. For instance,
/// if `clippy-driver` is set as the value for the wrapper,
/// then the correct bug report URL for `clippy` can be obtained.
workspace_wrapper: &'a Option<PathBuf>,
// A set of messages that have already been printed.
dedupe: HashSet<Message>,
}
impl<'a> DiagnosticPrinter<'a> {
pub fn new(
config: &'a Config,
workspace_wrapper: &'a Option<PathBuf>,
) -> DiagnosticPrinter<'a> {
DiagnosticPrinter {
config,
workspace_wrapper,
dedupe: HashSet::new(),
}
}
pub fn print(&mut self, msg: &Message) -> CargoResult<()> {
match msg {
Message::Migrating {
file,
from_edition,
to_edition,
} => {
if !self.dedupe.insert(msg.clone()) {
return Ok(());
}
self.config.shell().status(
"Migrating",
&format!("{} from {} edition to {}", file, from_edition, to_edition),
)
}
Message::Fixing { file } => self
.config
.shell()
.verbose(|shell| shell.status("Fixing", file)),
Message::Fixed { file, fixes } => {
let msg = if *fixes == 1 { "fix" } else { "fixes" };
let msg = format!("{} ({} {})", file, fixes, msg);
self.config.shell().status("Fixed", msg)
}
Message::ReplaceFailed { file, message } => {
let msg = format!("error applying suggestions to `{}`\n", file);
self.config.shell().warn(&msg)?;
write!(
self.config.shell().err(),
"The full error message was:\n\n> {}\n\n",
message,
)?;
let issue_link = get_bug_report_url(self.workspace_wrapper);
write!(
self.config.shell().err(),
"{}",
gen_please_report_this_bug_text(issue_link)
)?;
Ok(())
}
Message::FixFailed {
files,
krate,
errors,
abnormal_exit,
} => {
if let Some(ref krate) = *krate {
self.config.shell().warn(&format!(
"failed to automatically apply fixes suggested by rustc \
to crate `{}`",
krate,
))?;
} else {
self.config
.shell()
.warn("failed to automatically apply fixes suggested by rustc")?;
}
if !files.is_empty() {
writeln!(
self.config.shell().err(),
"\nafter fixes were automatically applied the compiler \
reported errors within these files:\n"
)?;
for file in files {
writeln!(self.config.shell().err(), " * {}", file)?;
}
writeln!(self.config.shell().err())?;
}
let issue_link = get_bug_report_url(self.workspace_wrapper);
write!(
self.config.shell().err(),
"{}",
gen_please_report_this_bug_text(issue_link)
)?;
if !errors.is_empty() {
writeln!(
self.config.shell().err(),
"The following errors were reported:"
)?;
for error in errors {
write!(self.config.shell().err(), "{}", error)?;
if !error.ends_with('\n') {
writeln!(self.config.shell().err())?;
}
}
}
if let Some(exit) = abnormal_exit {
writeln!(
self.config.shell().err(),
"rustc exited abnormally: {}",
exit
)?;
}
writeln!(
self.config.shell().err(),
"Original diagnostics will follow.\n"
)?;
Ok(())
}
Message::EditionAlreadyEnabled { message, edition } => {
if !self.dedupe.insert(msg.clone()) {
return Ok(());
}
// Don't give a really verbose warning if it has already been issued.
if self.dedupe.insert(Message::EditionAlreadyEnabled { | self.config.shell().warn(&format!("\
{}
If you are trying to migrate from the previous edition ({prev_edition}), the
process requires following these steps:
1. Start with `edition = \"{prev_edition}\"` in `Cargo.toml`
2. Run `cargo fix --edition`
3. Modify `Cargo.toml` to set `edition = \"{this_edition}\"`
4. Run `cargo build` or `cargo test` to verify the fixes worked
More details may be found at
https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
",
message, this_edition=edition, prev_edition=edition.previous().unwrap()
))
} else {
self.config.shell().warn(message)
}
}
}
}
}
fn gen_please_report_this_bug_text(url: &str) -> String {
format!(
"This likely indicates a bug in either rustc or cargo itself,\n\
and we would appreciate a bug report! You're likely to see \n\
a number of compiler warnings after this message which cargo\n\
attempted to fix but failed. If you could open an issue at\n\
{}\n\
quoting the full output of this command we'd be very appreciative!\n\
Note that you may be able to make some more progress in the near-term\n\
fixing code with the `--broken-code` flag\n\n\
",
url
)
}
fn get_bug_report_url(rustc_workspace_wrapper: &Option<PathBuf>) -> &str {
let clippy = std::ffi::OsStr::new("clippy-driver");
let issue_link = match rustc_workspace_wrapper.as_ref().and_then(|x| x.file_stem()) {
Some(wrapper) if wrapper == clippy => "https://github.com/rust-lang/rust-clippy/issues",
_ => "https://github.com/rust-lang/rust/issues",
};
issue_link
}
#[derive(Debug)]
pub struct RustfixDiagnosticServer {
listener: TcpListener,
addr: SocketAddr,
}
pub struct StartedServer {
addr: SocketAddr,
done: Arc<AtomicBool>,
thread: Option<JoinHandle<()>>,
}
impl RustfixDiagnosticServer {
pub fn new() -> Result<Self, Error> {
let listener = TcpListener::bind("127.0.0.1:0")
.with_context(|| "failed to bind TCP listener to manage locking")?;
let addr = listener.local_addr()?;
Ok(RustfixDiagnosticServer { listener, addr })
}
pub fn configure(&self, process: &mut ProcessBuilder) {
process.env(DIAGNOSTICS_SERVER_VAR, self.addr.to_string());
}
pub fn start<F>(self, on_message: F) -> Result<StartedServer, Error>
where
F: Fn(Message) + Send + 'static,
{
let addr = self.addr;
let done = Arc::new(AtomicBool::new(false));
let done2 = done.clone();
let thread = thread::spawn(move || {
self.run(&on_message, &done2);
});
Ok(StartedServer {
addr,
thread: Some(thread),
done,
})
}
fn run(self, on_message: &dyn Fn(Message), | message: "".to_string(), // Dummy, so that this only long-warns once.
edition: *edition,
}) { | random_line_split |
getast.go | , pkg, nil
}
// should return a list of *ast.TypeSpec we are interested in
func GetTypeSpecs(f *ast.File) []*ast.TypeSpec {
var out []*ast.TypeSpec
// check all declarations...
for i := range f.Decls {
// for GenDecls...
if g, ok := f.Decls[i].(*ast.GenDecl); ok {
// and check the specs...
for _, s := range g.Specs {
// for ast.TypeSpecs....
if ts, ok := s.(*ast.TypeSpec); ok {
out = append(out, ts)
// record identifier
switch ts.Type.(type) {
case *ast.StructType:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.Ident:
// we will resolve this later
globalIdents[ts.Name.Name] = pullIdent(ts.Type.(*ast.Ident).Name)
case *ast.ArrayType:
a := ts.Type.(*ast.ArrayType)
switch a.Elt.(type) {
case *ast.Ident:
if a.Elt.(*ast.Ident).Name == "byte" {
globalIdents[ts.Name.Name] = gen.Bytes
} else {
globalIdents[ts.Name.Name] = gen.IDENT
}
default:
globalIdents[ts.Name.Name] = gen.IDENT
}
case *ast.StarExpr:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.MapType:
globalIdents[ts.Name.Name] = gen.IDENT
}
}
}
}
}
return out
}
// GenElem creates the gen.Elem out of an
// ast.TypeSpec. Right now the only supported
// TypeSpec.Type is *ast.StructType
func GenElem(in *ast.TypeSpec) gen.Elem {
// handle supported types
switch in.Type.(type) {
case *ast.StructType:
v := in.Type.(*ast.StructType)
fmt.Printf(chalk.Green.Color("parsing %s..."), in.Name.Name)
p := &gen.Ptr{
Value: &gen.Struct{
Name: in.Name.Name, // ast.Ident
Fields: parseFieldList(v.Fields),
},
}
// mark type as processed
globalProcessed[in.Name.Name] = struct{}{}
if len(p.Value.(*gen.Struct).Fields) == 0 {
fmt.Printf(chalk.Red.Color(" has no exported fields \u2717\n")) // X
return nil
}
fmt.Print(chalk.Green.Color(" \u2713\n")) // check
return p
default:
return nil
}
}
func parseFieldList(fl *ast.FieldList) []gen.StructField {
if fl == nil || fl.NumFields() == 0 {
return nil
}
out := make([]gen.StructField, 0, fl.NumFields())
for_fields:
for _, field := range fl.List {
var sf gen.StructField
// field name
switch len(field.Names) {
case 1:
sf.FieldName = field.Names[0].Name
case 0:
sf.FieldName = embedded(field.Type)
if sf.FieldName == "" {
// means it's a selector expr., or
// something else unsupported
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %v unsupported)"), field.Type)
continue for_fields
}
default:
// inline multiple field declaration
for _, nm := range field.Names {
el := parseExpr(field.Type)
if el == nil {
// skip
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue for_fields
}
out = append(out, gen.StructField{
FieldTag: nm.Name,
FieldName: nm.Name,
FieldElem: el,
})
}
continue for_fields
}
// field tag
var flagExtension bool
if field.Tag != nil {
// we need to trim the leading and trailing ` characters for
// to convert to reflect.StructTag
body := reflect.StructTag(strings.Trim(field.Tag.Value, "`")).Get("msg")
// check for a tag like `msg:"name,extension"`
tags := strings.Split(body, ",")
if len(tags) > 1 && tags[1] == "extension" {
flagExtension = true
}
sf.FieldTag = tags[0]
}
if sf.FieldTag == "" {
sf.FieldTag = sf.FieldName
} else if sf.FieldTag == "-" {
// deliberately ignore field
continue for_fields
}
e := parseExpr(field.Type)
if e == nil {
// unsupported type
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue
}
// mark as extension
if flagExtension {
// an extension can be
// a pointer or base type
switch e.Type() {
case gen.PtrType:
if e.Ptr().Value.Type() == gen.BaseType {
e.Ptr().Value.Base().Value = gen.Ext
} else {
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
case gen.BaseType:
e.Base().Value = gen.Ext
default:
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
}
sf.FieldElem = e
out = append(out, sf)
}
return out
}
// extract embedded field name
func embedded(f ast.Expr) string {
switch f.(type) {
case *ast.Ident:
return f.(*ast.Ident).Name
case *ast.StarExpr:
return embedded(f.(*ast.StarExpr).X)
default:
// other possibilities (like selector expressions)
// are disallowed; we can't reasonably know
// their type
return ""
}
}
// go from ast.Expr to gen.Elem; nil means type not supported
func parseExpr(e ast.Expr) gen.Elem {
switch e.(type) {
case *ast.MapType:
switch e.(*ast.MapType).Key.(type) {
case *ast.Ident:
switch e.(*ast.MapType).Key.(*ast.Ident).Name {
case "string":
inner := parseExpr(e.(*ast.MapType).Value)
if inner == nil {
return nil
}
return &gen.Map{
Value: inner,
}
default:
return nil
}
default:
// we don't support non-string map keys
return nil
}
case *ast.Ident:
b := &gen.BaseElem{
Value: pullIdent(e.(*ast.Ident).Name),
}
if b.Value == gen.IDENT {
b.Ident = (e.(*ast.Ident).Name)
}
return b
case *ast.ArrayType:
arr := e.(*ast.ArrayType)
// array and not a slice
if arr.Len != nil {
switch arr.Len.(type) {
case *ast.BasicLit:
return &gen.Array{
Size: arr.Len.(*ast.BasicLit).Value,
Els: parseExpr(arr.Elt),
}
case *ast.Ident:
return &gen.Array{
Size: arr.Len.(*ast.Ident).String(),
Els: parseExpr(arr.Elt),
}
default:
return nil
}
}
// special case for []byte; others go to gen.Slice
switch arr.Elt.(type) {
case *ast.Ident:
i := arr.Elt.(*ast.Ident)
if i.Name == "byte" {
return &gen.BaseElem{
Value: gen.Bytes,
}
} else {
e := parseExpr(arr.Elt)
if e == nil {
return nil
}
return &gen.Slice{
Els: e,
}
}
default:
e := parseExpr(arr.Elt)
if e == nil {
return nil
}
return &gen.Slice{
Els: e,
}
}
case *ast.StarExpr:
v := parseExpr(e.(*ast.StarExpr).X)
if v == nil {
return nil
}
return &gen.Ptr{
Value: v,
}
case *ast.StructType:
return &gen.Struct{
Fields: parseFieldList(e.(*ast.StructType).Fields),
}
case *ast.SelectorExpr:
v := e.(*ast.SelectorExpr)
if im, ok := v.X.(*ast.Ident); ok {
if v.Sel.Name == "Time" && im.Name == "time" {
return &gen.BaseElem{
Value: gen.Time,
}
} else {
return &gen.BaseElem{
Value: gen.IDENT,
Ident: im.Name + "." + v.Sel.Name,
}
}
} | random_line_split | ||
getast.go | (filename string) (files []*ast.File, pkgName string, err error) {
var (
f *ast.File
fInfo os.FileInfo
)
fset := token.NewFileSet()
fInfo, err = os.Stat(filename)
if err != nil {
return
}
if fInfo.IsDir() {
var pkgs map[string]*ast.Package
pkgs, err = parser.ParseDir(fset, filename, nil, parser.AllErrors)
if err != nil {
return
}
// we'll assume one package per dir
var pkg *ast.Package
for _, pkg = range pkgs {
pkgName = pkg.Name
}
files = make([]*ast.File, len(pkg.Files))
var i = 0
for _, file := range pkg.Files {
files[i] = file
i++
}
return
}
f, err = parser.ParseFile(fset, filename, nil, parser.AllErrors)
if err != nil {
return
}
if !ast.FileExports(f) {
f, err = nil, errors.New("no exports in file")
}
files = []*ast.File{f}
if f != nil {
pkgName = f.Name.Name
}
return
}
// GetElems gets the generator elements out of a file (may be nil)
func GetElems(filename string) ([]gen.Elem, string, error) {
f, pkg, err := GetAST(filename)
if err != nil {
return nil, "", err
}
var specs []*ast.TypeSpec
for _, file := range f {
specs = append(specs, GetTypeSpecs(file)...)
}
if specs == nil {
return nil, "", nil
}
var out []gen.Elem
for i := range specs {
el := GenElem(specs[i])
if el != nil {
out = append(out, el)
}
}
var ptd bool
for _, o := range out {
unr := findUnresolved(o)
if unr != nil {
if !ptd {
fmt.Println(chalk.Yellow.Color("Non-local or unresolved identifiers:"))
ptd = true
}
for _, u := range unr {
fmt.Printf(chalk.Yellow.Color(" -> %q\n"), u)
}
}
}
return out, pkg, nil
}
// should return a list of *ast.TypeSpec we are interested in
func GetTypeSpecs(f *ast.File) []*ast.TypeSpec {
var out []*ast.TypeSpec
// check all declarations...
for i := range f.Decls {
// for GenDecls...
if g, ok := f.Decls[i].(*ast.GenDecl); ok {
// and check the specs...
for _, s := range g.Specs {
// for ast.TypeSpecs....
if ts, ok := s.(*ast.TypeSpec); ok {
out = append(out, ts)
// record identifier
switch ts.Type.(type) {
case *ast.StructType:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.Ident:
// we will resolve this later
globalIdents[ts.Name.Name] = pullIdent(ts.Type.(*ast.Ident).Name)
case *ast.ArrayType:
a := ts.Type.(*ast.ArrayType)
switch a.Elt.(type) {
case *ast.Ident:
if a.Elt.(*ast.Ident).Name == "byte" {
globalIdents[ts.Name.Name] = gen.Bytes
} else {
globalIdents[ts.Name.Name] = gen.IDENT
}
default:
globalIdents[ts.Name.Name] = gen.IDENT
}
case *ast.StarExpr:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.MapType:
globalIdents[ts.Name.Name] = gen.IDENT
}
}
}
}
}
return out
}
// GenElem creates the gen.Elem out of an
// ast.TypeSpec. Right now the only supported
// TypeSpec.Type is *ast.StructType
func GenElem(in *ast.TypeSpec) gen.Elem {
// handle supported types
switch in.Type.(type) {
case *ast.StructType:
v := in.Type.(*ast.StructType)
fmt.Printf(chalk.Green.Color("parsing %s..."), in.Name.Name)
p := &gen.Ptr{
Value: &gen.Struct{
Name: in.Name.Name, // ast.Ident
Fields: parseFieldList(v.Fields),
},
}
// mark type as processed
globalProcessed[in.Name.Name] = struct{}{}
if len(p.Value.(*gen.Struct).Fields) == 0 {
fmt.Printf(chalk.Red.Color(" has no exported fields \u2717\n")) // X
return nil
}
fmt.Print(chalk.Green.Color(" \u2713\n")) // check
return p
default:
return nil
}
}
func parseFieldList(fl *ast.FieldList) []gen.StructField {
if fl == nil || fl.NumFields() == 0 {
return nil
}
out := make([]gen.StructField, 0, fl.NumFields())
for_fields:
for _, field := range fl.List {
var sf gen.StructField
// field name
switch len(field.Names) {
case 1:
sf.FieldName = field.Names[0].Name
case 0:
sf.FieldName = embedded(field.Type)
if sf.FieldName == "" {
// means it's a selector expr., or
// something else unsupported
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %v unsupported)"), field.Type)
continue for_fields
}
default:
// inline multiple field declaration
for _, nm := range field.Names {
el := parseExpr(field.Type)
if el == nil {
// skip
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue for_fields
}
out = append(out, gen.StructField{
FieldTag: nm.Name,
FieldName: nm.Name,
FieldElem: el,
})
}
continue for_fields
}
// field tag
var flagExtension bool
if field.Tag != nil {
// we need to trim the leading and trailing ` characters for
// to convert to reflect.StructTag
body := reflect.StructTag(strings.Trim(field.Tag.Value, "`")).Get("msg")
// check for a tag like `msg:"name,extension"`
tags := strings.Split(body, ",")
if len(tags) > 1 && tags[1] == "extension" {
flagExtension = true
}
sf.FieldTag = tags[0]
}
if sf.FieldTag == "" {
sf.FieldTag = sf.FieldName
} else if sf.FieldTag == "-" {
// deliberately ignore field
continue for_fields
}
e := parseExpr(field.Type)
if e == nil {
// unsupported type
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue
}
// mark as extension
if flagExtension {
// an extension can be
// a pointer or base type
switch e.Type() {
case gen.PtrType:
if e.Ptr().Value.Type() == gen.BaseType {
e.Ptr().Value.Base().Value = gen.Ext
} else {
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
case gen.BaseType:
e.Base().Value = gen.Ext
default:
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
}
sf.FieldElem = e
out = append(out, sf)
}
return out
}
// extract embedded field name
func embedded(f ast.Expr) string {
switch f.(type) {
case *ast.Ident:
return f.(*ast.Ident).Name
case *ast.StarExpr:
return embedded(f.(*ast.StarExpr).X)
default:
// other possibilities (like selector expressions)
// are disallowed; we can't reasonably know
// their type
return ""
}
}
// go from ast.Expr to gen.Elem; nil means type not supported
func parseExpr(e ast.Expr) gen.Elem {
switch e.(type) {
case *ast.MapType:
switch e.(*ast.MapType).Key.(type) {
case *ast.Ident:
switch e.(*ast.MapType).Key.(*ast.Ident).Name {
case "string":
inner := parseExpr(e.(*ast.MapType).Value)
if inner == nil {
return nil
}
return &gen.Map{
Value: inner,
}
default:
return nil
}
default:
// we don't support non-string map keys
return nil
}
case *ast.Ident:
b := &gen.BaseElem{
Value: pullIdent(e.(*ast | GetAST | identifier_name | |
getast.go |
// GetAST simply creates the ast out of a filename and filters
// out non-exported elements.
func GetAST(filename string) (files []*ast.File, pkgName string, err error) {
var (
f *ast.File
fInfo os.FileInfo
)
fset := token.NewFileSet()
fInfo, err = os.Stat(filename)
if err != nil {
return
}
if fInfo.IsDir() {
var pkgs map[string]*ast.Package
pkgs, err = parser.ParseDir(fset, filename, nil, parser.AllErrors)
if err != nil {
return
}
// we'll assume one package per dir
var pkg *ast.Package
for _, pkg = range pkgs {
pkgName = pkg.Name
}
files = make([]*ast.File, len(pkg.Files))
var i = 0
for _, file := range pkg.Files {
files[i] = file
i++
}
return
}
f, err = parser.ParseFile(fset, filename, nil, parser.AllErrors)
if err != nil {
return
}
if !ast.FileExports(f) {
f, err = nil, errors.New("no exports in file")
}
files = []*ast.File{f}
if f != nil {
pkgName = f.Name.Name
}
return
}
// GetElems gets the generator elements out of a file (may be nil)
func GetElems(filename string) ([]gen.Elem, string, error) {
f, pkg, err := GetAST(filename)
if err != nil {
return nil, "", err
}
var specs []*ast.TypeSpec
for _, file := range f {
specs = append(specs, GetTypeSpecs(file)...)
}
if specs == nil {
return nil, "", nil
}
var out []gen.Elem
for i := range specs {
el := GenElem(specs[i])
if el != nil {
out = append(out, el)
}
}
var ptd bool
for _, o := range out {
unr := findUnresolved(o)
if unr != nil {
if !ptd {
fmt.Println(chalk.Yellow.Color("Non-local or unresolved identifiers:"))
ptd = true
}
for _, u := range unr {
fmt.Printf(chalk.Yellow.Color(" -> %q\n"), u)
}
}
}
return out, pkg, nil
}
// should return a list of *ast.TypeSpec we are interested in
func GetTypeSpecs(f *ast.File) []*ast.TypeSpec {
var out []*ast.TypeSpec
// check all declarations...
for i := range f.Decls {
// for GenDecls...
if g, ok := f.Decls[i].(*ast.GenDecl); ok {
// and check the specs...
for _, s := range g.Specs {
// for ast.TypeSpecs....
if ts, ok := s.(*ast.TypeSpec); ok {
out = append(out, ts)
// record identifier
switch ts.Type.(type) {
case *ast.StructType:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.Ident:
// we will resolve this later
globalIdents[ts.Name.Name] = pullIdent(ts.Type.(*ast.Ident).Name)
case *ast.ArrayType:
a := ts.Type.(*ast.ArrayType)
switch a.Elt.(type) {
case *ast.Ident:
if a.Elt.(*ast.Ident).Name == "byte" {
globalIdents[ts.Name.Name] = gen.Bytes
} else {
globalIdents[ts.Name.Name] = gen.IDENT
}
default:
globalIdents[ts.Name.Name] = gen.IDENT
}
case *ast.StarExpr:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.MapType:
globalIdents[ts.Name.Name] = gen.IDENT
}
}
}
}
}
return out
}
// GenElem creates the gen.Elem out of an
// ast.TypeSpec. Right now the only supported
// TypeSpec.Type is *ast.StructType
func GenElem(in *ast.TypeSpec) gen.Elem {
// handle supported types
switch in.Type.(type) {
case *ast.StructType:
v := in.Type.(*ast.StructType)
fmt.Printf(chalk.Green.Color("parsing %s..."), in.Name.Name)
p := &gen.Ptr{
Value: &gen.Struct{
Name: in.Name.Name, // ast.Ident
Fields: parseFieldList(v.Fields),
},
}
// mark type as processed
globalProcessed[in.Name.Name] = struct{}{}
if len(p.Value.(*gen.Struct).Fields) == 0 {
fmt.Printf(chalk.Red.Color(" has no exported fields \u2717\n")) // X
return nil
}
fmt.Print(chalk.Green.Color(" \u2713\n")) // check
return p
default:
return nil
}
}
func parseFieldList(fl *ast.FieldList) []gen.StructField {
if fl == nil || fl.NumFields() == 0 {
return nil
}
out := make([]gen.StructField, 0, fl.NumFields())
for_fields:
for _, field := range fl.List {
var sf gen.StructField
// field name
switch len(field.Names) {
case 1:
sf.FieldName = field.Names[0].Name
case 0:
sf.FieldName = embedded(field.Type)
if sf.FieldName == "" {
// means it's a selector expr., or
// something else unsupported
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %v unsupported)"), field.Type)
continue for_fields
}
default:
// inline multiple field declaration
for _, nm := range field.Names {
el := parseExpr(field.Type)
if el == nil {
// skip
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue for_fields
}
out = append(out, gen.StructField{
FieldTag: nm.Name,
FieldName: nm.Name,
FieldElem: el,
})
}
continue for_fields
}
// field tag
var flagExtension bool
if field.Tag != nil {
// we need to trim the leading and trailing ` characters for
// to convert to reflect.StructTag
body := reflect.StructTag(strings.Trim(field.Tag.Value, "`")).Get("msg")
// check for a tag like `msg:"name,extension"`
tags := strings.Split(body, ",")
if len(tags) > 1 && tags[1] == "extension" {
flagExtension = true
}
sf.FieldTag = tags[0]
}
if sf.FieldTag == "" {
sf.FieldTag = sf.FieldName
} else if sf.FieldTag == "-" {
// deliberately ignore field
continue for_fields
}
e := parseExpr(field.Type)
if e == nil {
// unsupported type
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue
}
// mark as extension
if flagExtension {
// an extension can be
// a pointer or base type
switch e.Type() {
case gen.PtrType:
if e.Ptr().Value.Type() == gen.BaseType {
e.Ptr().Value.Base().Value = gen.Ext
} else {
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
case gen.BaseType:
e.Base().Value = gen.Ext
default:
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
}
sf.FieldElem = e
out = append(out, sf)
}
return out
}
// extract embedded field name
func embedded(f ast.Expr) string {
switch f.(type) {
case *ast.Ident:
return f.(*ast.Ident).Name
case *ast.StarExpr:
return embedded(f.(*ast.StarExpr).X)
default:
// other possibilities (like selector expressions)
// are disallowed; we can't reasonably know
// their type
return ""
}
}
// go from ast.Expr to gen.Elem; nil means type not supported
func parseExpr(e ast.Expr) gen.Elem {
switch e.(type) {
case *ast.MapType:
switch e.(*ast.MapType).Key.(type) {
case *ast.Ident:
switch e.(*ast.MapType).Key.(*ast.Ident).Name {
case "string":
inner := parseExpr(e.(*ast.MapType).Value)
if inner == nil {
return nil
}
return &gen.Map{
Value: inner,
}
default:
return nil
| {
globalIdents = make(map[string]gen.Base)
globalProcessed = make(map[string]struct{})
} | identifier_body | |
getast.go | .AllErrors)
if err != nil {
return
}
// we'll assume one package per dir
var pkg *ast.Package
for _, pkg = range pkgs {
pkgName = pkg.Name
}
files = make([]*ast.File, len(pkg.Files))
var i = 0
for _, file := range pkg.Files {
files[i] = file
i++
}
return
}
f, err = parser.ParseFile(fset, filename, nil, parser.AllErrors)
if err != nil {
return
}
if !ast.FileExports(f) {
f, err = nil, errors.New("no exports in file")
}
files = []*ast.File{f}
if f != nil {
pkgName = f.Name.Name
}
return
}
// GetElems gets the generator elements out of a file (may be nil)
func GetElems(filename string) ([]gen.Elem, string, error) {
f, pkg, err := GetAST(filename)
if err != nil {
return nil, "", err
}
var specs []*ast.TypeSpec
for _, file := range f {
specs = append(specs, GetTypeSpecs(file)...)
}
if specs == nil {
return nil, "", nil
}
var out []gen.Elem
for i := range specs {
el := GenElem(specs[i])
if el != nil {
out = append(out, el)
}
}
var ptd bool
for _, o := range out {
unr := findUnresolved(o)
if unr != nil {
if !ptd {
fmt.Println(chalk.Yellow.Color("Non-local or unresolved identifiers:"))
ptd = true
}
for _, u := range unr {
fmt.Printf(chalk.Yellow.Color(" -> %q\n"), u)
}
}
}
return out, pkg, nil
}
// should return a list of *ast.TypeSpec we are interested in
func GetTypeSpecs(f *ast.File) []*ast.TypeSpec {
var out []*ast.TypeSpec
// check all declarations...
for i := range f.Decls {
// for GenDecls...
if g, ok := f.Decls[i].(*ast.GenDecl); ok {
// and check the specs...
for _, s := range g.Specs {
// for ast.TypeSpecs....
if ts, ok := s.(*ast.TypeSpec); ok {
out = append(out, ts)
// record identifier
switch ts.Type.(type) {
case *ast.StructType:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.Ident:
// we will resolve this later
globalIdents[ts.Name.Name] = pullIdent(ts.Type.(*ast.Ident).Name)
case *ast.ArrayType:
a := ts.Type.(*ast.ArrayType)
switch a.Elt.(type) {
case *ast.Ident:
if a.Elt.(*ast.Ident).Name == "byte" {
globalIdents[ts.Name.Name] = gen.Bytes
} else {
globalIdents[ts.Name.Name] = gen.IDENT
}
default:
globalIdents[ts.Name.Name] = gen.IDENT
}
case *ast.StarExpr:
globalIdents[ts.Name.Name] = gen.IDENT
case *ast.MapType:
globalIdents[ts.Name.Name] = gen.IDENT
}
}
}
}
}
return out
}
// GenElem creates the gen.Elem out of an
// ast.TypeSpec. Right now the only supported
// TypeSpec.Type is *ast.StructType
func GenElem(in *ast.TypeSpec) gen.Elem {
// handle supported types
switch in.Type.(type) {
case *ast.StructType:
v := in.Type.(*ast.StructType)
fmt.Printf(chalk.Green.Color("parsing %s..."), in.Name.Name)
p := &gen.Ptr{
Value: &gen.Struct{
Name: in.Name.Name, // ast.Ident
Fields: parseFieldList(v.Fields),
},
}
// mark type as processed
globalProcessed[in.Name.Name] = struct{}{}
if len(p.Value.(*gen.Struct).Fields) == 0 {
fmt.Printf(chalk.Red.Color(" has no exported fields \u2717\n")) // X
return nil
}
fmt.Print(chalk.Green.Color(" \u2713\n")) // check
return p
default:
return nil
}
}
func parseFieldList(fl *ast.FieldList) []gen.StructField {
if fl == nil || fl.NumFields() == 0 {
return nil
}
out := make([]gen.StructField, 0, fl.NumFields())
for_fields:
for _, field := range fl.List | // skip
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue for_fields
}
out = append(out, gen.StructField{
FieldTag: nm.Name,
FieldName: nm.Name,
FieldElem: el,
})
}
continue for_fields
}
// field tag
var flagExtension bool
if field.Tag != nil {
// we need to trim the leading and trailing ` characters for
// to convert to reflect.StructTag
body := reflect.StructTag(strings.Trim(field.Tag.Value, "`")).Get("msg")
// check for a tag like `msg:"name,extension"`
tags := strings.Split(body, ",")
if len(tags) > 1 && tags[1] == "extension" {
flagExtension = true
}
sf.FieldTag = tags[0]
}
if sf.FieldTag == "" {
sf.FieldTag = sf.FieldName
} else if sf.FieldTag == "-" {
// deliberately ignore field
continue for_fields
}
e := parseExpr(field.Type)
if e == nil {
// unsupported type
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q unsupported)"), sf.FieldName)
continue
}
// mark as extension
if flagExtension {
// an extension can be
// a pointer or base type
switch e.Type() {
case gen.PtrType:
if e.Ptr().Value.Type() == gen.BaseType {
e.Ptr().Value.Base().Value = gen.Ext
} else {
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
case gen.BaseType:
e.Base().Value = gen.Ext
default:
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %q couldn't be cast as an extension"), sf.FieldName)
continue
}
}
sf.FieldElem = e
out = append(out, sf)
}
return out
}
// extract embedded field name
func embedded(f ast.Expr) string {
switch f.(type) {
case *ast.Ident:
return f.(*ast.Ident).Name
case *ast.StarExpr:
return embedded(f.(*ast.StarExpr).X)
default:
// other possibilities (like selector expressions)
// are disallowed; we can't reasonably know
// their type
return ""
}
}
// go from ast.Expr to gen.Elem; nil means type not supported
func parseExpr(e ast.Expr) gen.Elem {
switch e.(type) {
case *ast.MapType:
switch e.(*ast.MapType).Key.(type) {
case *ast.Ident:
switch e.(*ast.MapType).Key.(*ast.Ident).Name {
case "string":
inner := parseExpr(e.(*ast.MapType).Value)
if inner == nil {
return nil
}
return &gen.Map{
Value: inner,
}
default:
return nil
}
default:
// we don't support non-string map keys
return nil
}
case *ast.Ident:
b := &gen.BaseElem{
Value: pullIdent(e.(*ast.Ident).Name),
}
if b.Value == gen.IDENT {
b.Ident = (e.(*ast.Ident).Name)
}
return b
case *ast.ArrayType:
arr := e.(*ast.ArrayType)
// array and not a slice
if arr.Len != nil {
switch arr.Len.(type) {
case *ast.BasicLit:
return &gen.Array{
Size: arr.Len.(*ast.Basic | {
var sf gen.StructField
// field name
switch len(field.Names) {
case 1:
sf.FieldName = field.Names[0].Name
case 0:
sf.FieldName = embedded(field.Type)
if sf.FieldName == "" {
// means it's a selector expr., or
// something else unsupported
fmt.Printf(chalk.Yellow.Color(" (\u26a0 field %v unsupported)"), field.Type)
continue for_fields
}
default:
// inline multiple field declaration
for _, nm := range field.Names {
el := parseExpr(field.Type)
if el == nil { | conditional_block |
main.go | else {
*ns = NullString{s.String, true}
}
return nil
}
type Env struct {
sqlDb *sql.DB
}
// json object to map the endpoint input data
type RequestInput struct {
Event_UUID string `json:"event_uuid"`
Username string `json:"username"`
Unix_timestamp int64 `json:"unix_timestamp"`
IP_Address string `json:"ip_address"`
}
// geo location of the IP in the request
type currentGeo struct {
Lat float64 `json:"lat"`
Lon float64 `json:"lon"`
Radius uint16 `json:"radius"`
}
// json object representing the preceeding or succeeding IP
type ipResponse struct {
Ip string `json:"ip,omitempty"'`
Speed *float32 `json:"speed,omitempty"`
Lat float64 `json:"lat,omitempty"`
Lon float64 `json:"lon,omitempty"`
Radius uint16 `json:"radius,omitempty"`
Timestamp int64 `json:"unix_timestamp,omitempty"`
}
// Error response json object
type errResponse struct {
Error string `json:"error"`
}
// Response json object
type Response struct {
CurrentGeo currentGeo `json:"currentGeo"`
TravelToCurrentGeoSuspicious *bool `json:"travelToCurrentGeoSuspicious,omitempty"`
TravelFromCurrentGeoSuspicious *bool `json:"travelFromCurrentGeoSuspicious,omitempty"`
PrecedingIpAccess ipResponse `json:"precedingIpAccess,omitempty"`
SubsequentIpAccess ipResponse `json:"subsequentIpAccess,omitempty"`
}
//var sqlDb *sql.DB
var tm *time.Time
var currHaversineCoord haversine.Coord
func (env *Env) home(writer http.ResponseWriter, req *http.Request){
decoder := json.NewDecoder(req.Body)
var input RequestInput
writer.Header().Set("Content-Type", "application/json")
err := decoder.Decode(&input)
if err != nil {
respondWithError(err.Error(), writer)
fmt.Println("handling ", req.RequestURI, ": ", err)
return
}
tm := time.Unix(input.Unix_timestamp, 0)
fmt.Println("UUID: ", input.Event_UUID)
fmt.Println("Username: ", input.Username)
fmt.Println("IP Address: ", input.IP_Address)
fmt.Println("Time: ", tm)
// Check for valid IP address
valid_ip := net.ParseIP(input.IP_Address)
if valid_ip == nil {
respondWithError("Invalid IP Address", writer)
fmt.Println("Invalid IP Address: ", input.IP_Address)
return
}
// building a temp table that appends row_number column which is used in join condition
selectStatement := fmt.Sprintf(`with new_table
AS (select uuid, username, ipaddress, date_time,ROW_NUMBER() OVER (order by date_time) row_no FROM request where username="%s")
select t.uuid, t.username, t.ipaddress, t.date_time, t1.uuid, t1.username, t1.ipaddress, t1.date_time, t2.uuid, t2.username, t2.ipaddress, t2.date_time from (select * from new_table where date_time="%s" and ipaddress="%s") as t
LEFT JOIN (select * from new_table) as t1 ON t1.row_no = t.row_no-1
LEFT JOIN (select * from new_table) as t2 ON t2.row_no = t.row_no+1;`, input.Username, strconv.FormatInt(input.Unix_timestamp, 10), input.IP_Address)
tx, err := env.sqlDb.Begin()
if err != nil {
log.Fatal(err)
panic(err)
}
// insert the request data into the database
_, err = env.sqlDb.Exec("insert into request(uuid, username, ipaddress, date_time) values(?, ?, ?, ?)", input.Event_UUID, input.Username, input.IP_Address, input.Unix_timestamp)
if err != nil {
log.Fatal(err)
panic(err)
}
tx.Commit()
// Defined the paramters as NullString to handle dereferencing issue with nil values returned from the database.
type sqlrow struct {
uuid NullString
username NullString
ipaddress NullString
date_time NullString
}
// variables to hold the current, preceeding and succeeding database records
var t, t1, t2 sqlrow
row := env.sqlDb.QueryRow(selectStatement)
switch err := row.Scan(&t.uuid, &t.username, &t.ipaddress, &t.date_time, &t1.uuid, &t1.username, &t1.ipaddress, &t1.date_time, &t2.uuid, &t2.username, &t2.ipaddress, &t2.date_time); err {
case sql.ErrNoRows:
fmt.Println("No rows were returned!")
case nil:
var current = currentGeo{} // json object referencing the request data geo location
var preceeding = ipResponse{} // json object referencing the preceeding immediate request w.r.t the request data
var succeeding = ipResponse{}// json object referencing the succeeding immediate request w.r.t the request data
var resp = Response{} // response json that is returned to the end user
var preceedingHaversineCoord haversine.Coord
var succeedingHaversineCoord haversine.Coord
current.Lat, current.Lon, current.Radius = GetLatitudeAndLongitude(input.IP_Address)
if current.Lat != -10000 {
resp.CurrentGeo = current
currHaversineCoord = haversine.Coord{Lat:current.Lat, Lon:current.Lon}
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for ip %s", input.IP_Address), writer)
return
}
// if t1.uuid is not null
if t1.uuid.Valid {
preceeding.Lat, preceeding.Lon, preceeding.Radius = GetLatitudeAndLongitude(t1.ipaddress.String)
if preceeding.Lat != -10000 {
// creating a bool and speed object so that the json keys can map to these objects so that they are not ignored
// when displaying 0 or nil values because of omitempty flag set on the key
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t1.date_time.String, 10, 64)
preceeding.Timestamp = tm1
preceeding.Ip = t1.ipaddress.String
preceedingHaversineCoord = haversine.Coord{Lat: preceeding.Lat, Lon: preceeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, preceedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(preceeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelToCurrentGeoSuspicious = tr
} else {
tmDiff := tm.Sub(time.Unix(tm1, 0)).Hours()
// if hour is less than 0 assume hour = 1
if tmDiff == 0 {
tmDiff = 1
}
// Setting the suspicion flag to true if the speed to travel from preceeding location to the current location is greater than 500
*speed = float32(dist / tmDiff)
if *speed > 500 {
*tr = true
}
resp.TravelToCurrentGeoSuspicious = tr
}
preceeding.Speed = speed
resp.PrecedingIpAccess = preceeding
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for preceeding ip %s", t1.ipaddress.String), writer)
return
}
}
// if t2.uuid is not null
if t2.uuid.Valid {
succeeding.Lat, succeeding.Lon, succeeding.Radius = GetLatitudeAndLongitude(t2.ipaddress.String)
if succeeding.Lat != -10000 {
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t2.date_time.String, 10, 64)
succeeding.Timestamp = tm1
succeeding.Ip = t2.ipaddress.String
succeedingHaversineCoord = haversine.Coord{Lat: succeeding.Lat, Lon: succeeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, succeedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be | {
*ns = NullString{s.String, false}
} | conditional_block | |
main.go | _address"`
}
// geo location of the IP in the request
type currentGeo struct {
Lat float64 `json:"lat"`
Lon float64 `json:"lon"`
Radius uint16 `json:"radius"`
}
// json object representing the preceeding or succeeding IP
type ipResponse struct {
Ip string `json:"ip,omitempty"'`
Speed *float32 `json:"speed,omitempty"`
Lat float64 `json:"lat,omitempty"`
Lon float64 `json:"lon,omitempty"`
Radius uint16 `json:"radius,omitempty"`
Timestamp int64 `json:"unix_timestamp,omitempty"`
}
// Error response json object
type errResponse struct {
Error string `json:"error"`
}
// Response json object
type Response struct {
CurrentGeo currentGeo `json:"currentGeo"`
TravelToCurrentGeoSuspicious *bool `json:"travelToCurrentGeoSuspicious,omitempty"`
TravelFromCurrentGeoSuspicious *bool `json:"travelFromCurrentGeoSuspicious,omitempty"`
PrecedingIpAccess ipResponse `json:"precedingIpAccess,omitempty"`
SubsequentIpAccess ipResponse `json:"subsequentIpAccess,omitempty"`
}
//var sqlDb *sql.DB
var tm *time.Time
var currHaversineCoord haversine.Coord
func (env *Env) home(writer http.ResponseWriter, req *http.Request) | if valid_ip == nil {
respondWithError("Invalid IP Address", writer)
fmt.Println("Invalid IP Address: ", input.IP_Address)
return
}
// building a temp table that appends row_number column which is used in join condition
selectStatement := fmt.Sprintf(`with new_table
AS (select uuid, username, ipaddress, date_time,ROW_NUMBER() OVER (order by date_time) row_no FROM request where username="%s")
select t.uuid, t.username, t.ipaddress, t.date_time, t1.uuid, t1.username, t1.ipaddress, t1.date_time, t2.uuid, t2.username, t2.ipaddress, t2.date_time from (select * from new_table where date_time="%s" and ipaddress="%s") as t
LEFT JOIN (select * from new_table) as t1 ON t1.row_no = t.row_no-1
LEFT JOIN (select * from new_table) as t2 ON t2.row_no = t.row_no+1;`, input.Username, strconv.FormatInt(input.Unix_timestamp, 10), input.IP_Address)
tx, err := env.sqlDb.Begin()
if err != nil {
log.Fatal(err)
panic(err)
}
// insert the request data into the database
_, err = env.sqlDb.Exec("insert into request(uuid, username, ipaddress, date_time) values(?, ?, ?, ?)", input.Event_UUID, input.Username, input.IP_Address, input.Unix_timestamp)
if err != nil {
log.Fatal(err)
panic(err)
}
tx.Commit()
// Defined the paramters as NullString to handle dereferencing issue with nil values returned from the database.
type sqlrow struct {
uuid NullString
username NullString
ipaddress NullString
date_time NullString
}
// variables to hold the current, preceeding and succeeding database records
var t, t1, t2 sqlrow
row := env.sqlDb.QueryRow(selectStatement)
switch err := row.Scan(&t.uuid, &t.username, &t.ipaddress, &t.date_time, &t1.uuid, &t1.username, &t1.ipaddress, &t1.date_time, &t2.uuid, &t2.username, &t2.ipaddress, &t2.date_time); err {
case sql.ErrNoRows:
fmt.Println("No rows were returned!")
case nil:
var current = currentGeo{} // json object referencing the request data geo location
var preceeding = ipResponse{} // json object referencing the preceeding immediate request w.r.t the request data
var succeeding = ipResponse{}// json object referencing the succeeding immediate request w.r.t the request data
var resp = Response{} // response json that is returned to the end user
var preceedingHaversineCoord haversine.Coord
var succeedingHaversineCoord haversine.Coord
current.Lat, current.Lon, current.Radius = GetLatitudeAndLongitude(input.IP_Address)
if current.Lat != -10000 {
resp.CurrentGeo = current
currHaversineCoord = haversine.Coord{Lat:current.Lat, Lon:current.Lon}
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for ip %s", input.IP_Address), writer)
return
}
// if t1.uuid is not null
if t1.uuid.Valid {
preceeding.Lat, preceeding.Lon, preceeding.Radius = GetLatitudeAndLongitude(t1.ipaddress.String)
if preceeding.Lat != -10000 {
// creating a bool and speed object so that the json keys can map to these objects so that they are not ignored
// when displaying 0 or nil values because of omitempty flag set on the key
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t1.date_time.String, 10, 64)
preceeding.Timestamp = tm1
preceeding.Ip = t1.ipaddress.String
preceedingHaversineCoord = haversine.Coord{Lat: preceeding.Lat, Lon: preceeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, preceedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(preceeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelToCurrentGeoSuspicious = tr
} else {
tmDiff := tm.Sub(time.Unix(tm1, 0)).Hours()
// if hour is less than 0 assume hour = 1
if tmDiff == 0 {
tmDiff = 1
}
// Setting the suspicion flag to true if the speed to travel from preceeding location to the current location is greater than 500
*speed = float32(dist / tmDiff)
if *speed > 500 {
*tr = true
}
resp.TravelToCurrentGeoSuspicious = tr
}
preceeding.Speed = speed
resp.PrecedingIpAccess = preceeding
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for preceeding ip %s", t1.ipaddress.String), writer)
return
}
}
// if t2.uuid is not null
if t2.uuid.Valid {
succeeding.Lat, succeeding.Lon, succeeding.Radius = GetLatitudeAndLongitude(t2.ipaddress.String)
if succeeding.Lat != -10000 {
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t2.date_time.String, 10, 64)
succeeding.Timestamp = tm1
succeeding.Ip = t2.ipaddress.String
succeedingHaversineCoord = haversine.Coord{Lat: succeeding.Lat, Lon: succeeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, succeedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(succeeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelFromCurrentGeoSuspicious = tr
} else {
| {
decoder := json.NewDecoder(req.Body)
var input RequestInput
writer.Header().Set("Content-Type", "application/json")
err := decoder.Decode(&input)
if err != nil {
respondWithError(err.Error(), writer)
fmt.Println("handling ", req.RequestURI, ": ", err)
return
}
tm := time.Unix(input.Unix_timestamp, 0)
fmt.Println("UUID: ", input.Event_UUID)
fmt.Println("Username: ", input.Username)
fmt.Println("IP Address: ", input.IP_Address)
fmt.Println("Time: ", tm)
// Check for valid IP address
valid_ip := net.ParseIP(input.IP_Address) | identifier_body |
main.go | _address"`
}
// geo location of the IP in the request
type currentGeo struct {
Lat float64 `json:"lat"`
Lon float64 `json:"lon"`
Radius uint16 `json:"radius"`
}
// json object representing the preceeding or succeeding IP
type ipResponse struct {
Ip string `json:"ip,omitempty"'`
Speed *float32 `json:"speed,omitempty"`
Lat float64 `json:"lat,omitempty"`
Lon float64 `json:"lon,omitempty"`
Radius uint16 `json:"radius,omitempty"`
Timestamp int64 `json:"unix_timestamp,omitempty"`
}
// Error response json object
type errResponse struct {
Error string `json:"error"`
}
// Response json object
type Response struct {
CurrentGeo currentGeo `json:"currentGeo"`
TravelToCurrentGeoSuspicious *bool `json:"travelToCurrentGeoSuspicious,omitempty"`
TravelFromCurrentGeoSuspicious *bool `json:"travelFromCurrentGeoSuspicious,omitempty"`
PrecedingIpAccess ipResponse `json:"precedingIpAccess,omitempty"`
SubsequentIpAccess ipResponse `json:"subsequentIpAccess,omitempty"`
}
//var sqlDb *sql.DB
var tm *time.Time
var currHaversineCoord haversine.Coord
func (env *Env) | (writer http.ResponseWriter, req *http.Request){
decoder := json.NewDecoder(req.Body)
var input RequestInput
writer.Header().Set("Content-Type", "application/json")
err := decoder.Decode(&input)
if err != nil {
respondWithError(err.Error(), writer)
fmt.Println("handling ", req.RequestURI, ": ", err)
return
}
tm := time.Unix(input.Unix_timestamp, 0)
fmt.Println("UUID: ", input.Event_UUID)
fmt.Println("Username: ", input.Username)
fmt.Println("IP Address: ", input.IP_Address)
fmt.Println("Time: ", tm)
// Check for valid IP address
valid_ip := net.ParseIP(input.IP_Address)
if valid_ip == nil {
respondWithError("Invalid IP Address", writer)
fmt.Println("Invalid IP Address: ", input.IP_Address)
return
}
// building a temp table that appends row_number column which is used in join condition
selectStatement := fmt.Sprintf(`with new_table
AS (select uuid, username, ipaddress, date_time,ROW_NUMBER() OVER (order by date_time) row_no FROM request where username="%s")
select t.uuid, t.username, t.ipaddress, t.date_time, t1.uuid, t1.username, t1.ipaddress, t1.date_time, t2.uuid, t2.username, t2.ipaddress, t2.date_time from (select * from new_table where date_time="%s" and ipaddress="%s") as t
LEFT JOIN (select * from new_table) as t1 ON t1.row_no = t.row_no-1
LEFT JOIN (select * from new_table) as t2 ON t2.row_no = t.row_no+1;`, input.Username, strconv.FormatInt(input.Unix_timestamp, 10), input.IP_Address)
tx, err := env.sqlDb.Begin()
if err != nil {
log.Fatal(err)
panic(err)
}
// insert the request data into the database
_, err = env.sqlDb.Exec("insert into request(uuid, username, ipaddress, date_time) values(?, ?, ?, ?)", input.Event_UUID, input.Username, input.IP_Address, input.Unix_timestamp)
if err != nil {
log.Fatal(err)
panic(err)
}
tx.Commit()
// Defined the paramters as NullString to handle dereferencing issue with nil values returned from the database.
type sqlrow struct {
uuid NullString
username NullString
ipaddress NullString
date_time NullString
}
// variables to hold the current, preceeding and succeeding database records
var t, t1, t2 sqlrow
row := env.sqlDb.QueryRow(selectStatement)
switch err := row.Scan(&t.uuid, &t.username, &t.ipaddress, &t.date_time, &t1.uuid, &t1.username, &t1.ipaddress, &t1.date_time, &t2.uuid, &t2.username, &t2.ipaddress, &t2.date_time); err {
case sql.ErrNoRows:
fmt.Println("No rows were returned!")
case nil:
var current = currentGeo{} // json object referencing the request data geo location
var preceeding = ipResponse{} // json object referencing the preceeding immediate request w.r.t the request data
var succeeding = ipResponse{}// json object referencing the succeeding immediate request w.r.t the request data
var resp = Response{} // response json that is returned to the end user
var preceedingHaversineCoord haversine.Coord
var succeedingHaversineCoord haversine.Coord
current.Lat, current.Lon, current.Radius = GetLatitudeAndLongitude(input.IP_Address)
if current.Lat != -10000 {
resp.CurrentGeo = current
currHaversineCoord = haversine.Coord{Lat:current.Lat, Lon:current.Lon}
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for ip %s", input.IP_Address), writer)
return
}
// if t1.uuid is not null
if t1.uuid.Valid {
preceeding.Lat, preceeding.Lon, preceeding.Radius = GetLatitudeAndLongitude(t1.ipaddress.String)
if preceeding.Lat != -10000 {
// creating a bool and speed object so that the json keys can map to these objects so that they are not ignored
// when displaying 0 or nil values because of omitempty flag set on the key
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t1.date_time.String, 10, 64)
preceeding.Timestamp = tm1
preceeding.Ip = t1.ipaddress.String
preceedingHaversineCoord = haversine.Coord{Lat: preceeding.Lat, Lon: preceeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, preceedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(preceeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelToCurrentGeoSuspicious = tr
} else {
tmDiff := tm.Sub(time.Unix(tm1, 0)).Hours()
// if hour is less than 0 assume hour = 1
if tmDiff == 0 {
tmDiff = 1
}
// Setting the suspicion flag to true if the speed to travel from preceeding location to the current location is greater than 500
*speed = float32(dist / tmDiff)
if *speed > 500 {
*tr = true
}
resp.TravelToCurrentGeoSuspicious = tr
}
preceeding.Speed = speed
resp.PrecedingIpAccess = preceeding
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for preceeding ip %s", t1.ipaddress.String), writer)
return
}
}
// if t2.uuid is not null
if t2.uuid.Valid {
succeeding.Lat, succeeding.Lon, succeeding.Radius = GetLatitudeAndLongitude(t2.ipaddress.String)
if succeeding.Lat != -10000 {
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t2.date_time.String, 10, 64)
succeeding.Timestamp = tm1
succeeding.Ip = t2.ipaddress.String
succeedingHaversineCoord = haversine.Coord{Lat: succeeding.Lat, Lon: succeeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, succeedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(succeeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelFromCurrentGeoSuspicious = tr
} else {
| home | identifier_name |
main.go | _address"`
}
// geo location of the IP in the request
type currentGeo struct {
Lat float64 `json:"lat"`
Lon float64 `json:"lon"`
Radius uint16 `json:"radius"`
}
// json object representing the preceeding or succeeding IP
type ipResponse struct {
Ip string `json:"ip,omitempty"'`
Speed *float32 `json:"speed,omitempty"`
Lat float64 `json:"lat,omitempty"`
Lon float64 `json:"lon,omitempty"`
Radius uint16 `json:"radius,omitempty"`
Timestamp int64 `json:"unix_timestamp,omitempty"`
}
// Error response json object
type errResponse struct {
Error string `json:"error"`
}
// Response json object
type Response struct {
CurrentGeo currentGeo `json:"currentGeo"`
TravelToCurrentGeoSuspicious *bool `json:"travelToCurrentGeoSuspicious,omitempty"`
TravelFromCurrentGeoSuspicious *bool `json:"travelFromCurrentGeoSuspicious,omitempty"`
PrecedingIpAccess ipResponse `json:"precedingIpAccess,omitempty"`
SubsequentIpAccess ipResponse `json:"subsequentIpAccess,omitempty"`
}
//var sqlDb *sql.DB
var tm *time.Time
var currHaversineCoord haversine.Coord
func (env *Env) home(writer http.ResponseWriter, req *http.Request){
decoder := json.NewDecoder(req.Body)
var input RequestInput
writer.Header().Set("Content-Type", "application/json")
err := decoder.Decode(&input)
if err != nil {
respondWithError(err.Error(), writer)
fmt.Println("handling ", req.RequestURI, ": ", err)
return
}
tm := time.Unix(input.Unix_timestamp, 0)
fmt.Println("UUID: ", input.Event_UUID)
fmt.Println("Username: ", input.Username)
fmt.Println("IP Address: ", input.IP_Address)
fmt.Println("Time: ", tm)
// Check for valid IP address
valid_ip := net.ParseIP(input.IP_Address)
if valid_ip == nil {
respondWithError("Invalid IP Address", writer)
fmt.Println("Invalid IP Address: ", input.IP_Address)
return
}
// building a temp table that appends row_number column which is used in join condition
selectStatement := fmt.Sprintf(`with new_table
AS (select uuid, username, ipaddress, date_time,ROW_NUMBER() OVER (order by date_time) row_no FROM request where username="%s")
select t.uuid, t.username, t.ipaddress, t.date_time, t1.uuid, t1.username, t1.ipaddress, t1.date_time, t2.uuid, t2.username, t2.ipaddress, t2.date_time from (select * from new_table where date_time="%s" and ipaddress="%s") as t
LEFT JOIN (select * from new_table) as t1 ON t1.row_no = t.row_no-1
LEFT JOIN (select * from new_table) as t2 ON t2.row_no = t.row_no+1;`, input.Username, strconv.FormatInt(input.Unix_timestamp, 10), input.IP_Address)
tx, err := env.sqlDb.Begin()
if err != nil {
log.Fatal(err)
panic(err)
}
// insert the request data into the database | tx.Commit()
// Defined the paramters as NullString to handle dereferencing issue with nil values returned from the database.
type sqlrow struct {
uuid NullString
username NullString
ipaddress NullString
date_time NullString
}
// variables to hold the current, preceeding and succeeding database records
var t, t1, t2 sqlrow
row := env.sqlDb.QueryRow(selectStatement)
switch err := row.Scan(&t.uuid, &t.username, &t.ipaddress, &t.date_time, &t1.uuid, &t1.username, &t1.ipaddress, &t1.date_time, &t2.uuid, &t2.username, &t2.ipaddress, &t2.date_time); err {
case sql.ErrNoRows:
fmt.Println("No rows were returned!")
case nil:
var current = currentGeo{} // json object referencing the request data geo location
var preceeding = ipResponse{} // json object referencing the preceeding immediate request w.r.t the request data
var succeeding = ipResponse{}// json object referencing the succeeding immediate request w.r.t the request data
var resp = Response{} // response json that is returned to the end user
var preceedingHaversineCoord haversine.Coord
var succeedingHaversineCoord haversine.Coord
current.Lat, current.Lon, current.Radius = GetLatitudeAndLongitude(input.IP_Address)
if current.Lat != -10000 {
resp.CurrentGeo = current
currHaversineCoord = haversine.Coord{Lat:current.Lat, Lon:current.Lon}
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for ip %s", input.IP_Address), writer)
return
}
// if t1.uuid is not null
if t1.uuid.Valid {
preceeding.Lat, preceeding.Lon, preceeding.Radius = GetLatitudeAndLongitude(t1.ipaddress.String)
if preceeding.Lat != -10000 {
// creating a bool and speed object so that the json keys can map to these objects so that they are not ignored
// when displaying 0 or nil values because of omitempty flag set on the key
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t1.date_time.String, 10, 64)
preceeding.Timestamp = tm1
preceeding.Ip = t1.ipaddress.String
preceedingHaversineCoord = haversine.Coord{Lat: preceeding.Lat, Lon: preceeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, preceedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(preceeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelToCurrentGeoSuspicious = tr
} else {
tmDiff := tm.Sub(time.Unix(tm1, 0)).Hours()
// if hour is less than 0 assume hour = 1
if tmDiff == 0 {
tmDiff = 1
}
// Setting the suspicion flag to true if the speed to travel from preceeding location to the current location is greater than 500
*speed = float32(dist / tmDiff)
if *speed > 500 {
*tr = true
}
resp.TravelToCurrentGeoSuspicious = tr
}
preceeding.Speed = speed
resp.PrecedingIpAccess = preceeding
} else {
respondWithError(fmt.Sprintf("Error retreiving geo location for preceeding ip %s", t1.ipaddress.String), writer)
return
}
}
// if t2.uuid is not null
if t2.uuid.Valid {
succeeding.Lat, succeeding.Lon, succeeding.Radius = GetLatitudeAndLongitude(t2.ipaddress.String)
if succeeding.Lat != -10000 {
tr := new(bool)
speed := new(float32)
tm1, _ := strconv.ParseInt(t2.date_time.String, 10, 64)
succeeding.Timestamp = tm1
succeeding.Ip = t2.ipaddress.String
succeedingHaversineCoord = haversine.Coord{Lat: succeeding.Lat, Lon: succeeding.Lon}
dist, _ := haversine.Distance(currHaversineCoord, succeedingHaversineCoord)
// Deducting the accuracy radius for both the locations from the previous haversine distance, considering the
// location can be anywhere within the radius. In this case i'm assuming its on the circle. Before deducting
// convert radius in kilometers to miles by multiplying with conversion factor 0.6214
finalDist := dist - (float64(succeeding.Radius) + float64(current.Radius)) * 0.6214
if finalDist < 0 {
finalDist = 0
resp.TravelFromCurrentGeoSuspicious = tr
} else {
tm | _, err = env.sqlDb.Exec("insert into request(uuid, username, ipaddress, date_time) values(?, ?, ?, ?)", input.Event_UUID, input.Username, input.IP_Address, input.Unix_timestamp)
if err != nil {
log.Fatal(err)
panic(err)
} | random_line_split |
btc-arbitrage.ts | TT.Factories.GDAX.FeedFactory(logger, products).then((feed: GDAXFeed) => {
// Configure all message streams to use the same websocket feed
// Create the source message streams by creating a MessageStream for each product, using the same WS feed for each
const streams = products.map((product) => new GTT.Core.ProductFilter({ logger: logger, productId: product }));
const outStream = new Array(products.length);
for (let i = 0; i < products.length; i++) {
outStream[i] = feed.pipe(streams[i]);
latest[i] = Big(-100000);
}
for (let i = 0; i < latest.length; i++) {
outStream[i].on('data', (msg: StreamMessage) => {
if (msg.type === 'trade') {
mangeTradeMessage(i, msg as TradeMessage);
}
if(msg.type !== 'level' && msg.type !== 'myOrderPlaced' && msg.type !== 'tradeExecuted' && msg.type !== 'tradeFinalized' && msg.type !== 'trade' && msg.type !== 'snapshot' && msg.type !== 'ticker' && msg.type !== 'unknown'){
console.log('Message Type: ' + msg.type)
}
if (msg.type === 'tradeExecuted') {//|| msg.type === 'tradeFinalized'){
console.log('Message Type: ' + msg.type)
process.stdout.write("\x07");
}
});
}
});
function mangeTradeMessage(index: number, msg: TradeMessage) {
let price = Big(msg.price);
// make the two exchange rates (ETH-BTC, LTC-BTC)relative to BTC-USD
if (products[index] === 'ETH-BTC' || products[index] === 'LTC-BTC'){
if (products[index] === 'ETH-BTC' ) {
latest_eth_btc_conversion = price;
}
let btc_usd = latest[BTC_USD_i];
if (btc_usd.gt(zero)) {
latest[index] = price.times(btc_usd);
}
// once this next line has run once you are all necessary infomation is in place to trade for the respective currency.
products[index] === 'ETH-BTC' ? ready[0] = true : ready[1] = true;
} else {
latest[index] = price;
}
// calculate the diff in prices between buying currency x in BTC vs USD
diff[0] = latest[ETH_USD_i].minus(latest[ETH_BTC_i]);
diff[1] = latest[LTC_USD_i].minus( latest[LTC_BTC_i]);
// if were not ready yet dont try to process the arbitrage.
if (!ready[0] || latest[ETH_BTC_i].lt(zero) || latest[ETH_USD_i].lt(zero) || latest[BTC_USD_i].lt(zero)) {
return
}
printUnderline(latest, index);
printLatestPrices(diff);
let randNumber = getRandomInt(0, 200);
if(randNumber != 10) {
// console.log(`skip order: ${randNumber}`);
return
}
process.stdout.write('🎯');
let eth_diff = diff[0];
processArbitrage(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
processArbitrage2(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
}
function printLatestPrices(prices: BigJS[]) {
// const cur = ['BTC-USD', 'ETH-BTC', 'LTC-BTC'];
const diffLabels = ['ETH', 'LTC'];
const pstr = diffLabels.map((c, i) => `${c} ${padfloat(prices[i], 6, 6)}`);
const msg = pstr.join(' | ');
// process.stdout.write(msg + ' | ');
console.log(' | ' + msg);
}
function printUnderline(prices: BigJS[], changeIndex: number) {
const pstr = products.map((c, i) => `${c}${i === changeIndex ? "\x1b[36m" : ""} ${padfloat(prices[i], 6, 6)} ${i === changeIndex ? "\x1b[0m" : ""}`);
const msg = pstr.join(' | ');
process.stdout.write(msg)
}
function orderMessageWithREST(side: string, product: string, amount: string, price: string) {
const [base, quote] = product.split('-');
console.log(side + ' ' + base + ' ' + amount + ' ' + product + '@ ' + price);
const order: PlaceOrderMessage = {
time: new Date(),
type: 'placeOrder',
productId: product,
size: amount,
price: price,
side: side,
orderType: 'limit',
postOnly: true
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Order executed', `Order to ${order.side} ${amount} ${base} for ${price} ${quote} placed. Result: ${result.status}`);
processOrderResult(result, order)
}).catch(logError);
return order;
}
function orderMarketMessage(side: string, product: string, amount: string, price: string) {
console.log(side + ' ' + amount + ' ' + product + '@ ' + price + ' - ' + amount);
const [base, quote] = product.split('-');
const order: PlaceOrderMessage = {
type: 'order',
time: new Date(),
productId: product,
orderType: 'market',
side: side,
size: amount
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Market order executed ', `Order to ${order.side} ${amount} ${base} placed. Result: ${result.status}`);
});
return order;
}
let executedArbitrage = false;
function processArbitrage(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(1);
let min_increment = Big(0.01);
if (arbitrageValue.lte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lte(zero)) {return}
if (arbitrageValue.lt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
let buy_price = eth_btc;
let btc_min_amount = Big(0.01);
let amount = btc_min_amount.div(eth_btc); //0.01 / 0.04472 = 0.22361359
let sell_price = eth_price2.plus(min_increment);
let buy_price2 = btc_price.minus(min_increment);
let eth_needed = btc_min_amount.div(eth_btc); |
console.log(`arbitrageValue: ${arbitrageValue}`);
sufficentBalances(btc_needed, eth_needed, usd_needed).then(result => {
if (!result) {
console.log('Insufficient Balances');
return
}
// alert me.
process.stdout.write("\x07");
// buy eth with bitcoin
orderMessageWithREST('buy', 'ETH-BTC', amount.toFixed(8), buy_price.toFixed(5));
console.log('buy ' + amount + ' eth @ ' + buy_price);
// sell eth for usd
orderMessageWithREST('sell', 'ETH-USD', amount.toFixed(8), sell_price.toFixed(2));
console.log('sell 0.01 eth for this many usd: ' + sell_price.toFixed(2));
// buy bitcoin with usd
orderMessageWithREST('buy', 'BTC-USD', `${btc_min_amount.toFixed(2)}`, buy_price2.toFixed(2));
console.log('buy bitcoin with usd: ' + buy_price2.toFixed(2));
executedArbitrage = true
});
executedArbitrage = true
}
function processArbitrage2(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(-1);
let min_increment = Big(0.01);
if (arbitrageValue.gte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lt(zero)) {return}
if (arbitrageValue.gt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
// i need 0.01 BTC
// I need 0.01 / btc_eth exchange rate
// I need 0.01 | let btc_needed = eth_btc.times(amount);
let usd_needed = btc_min_amount.times(btc_price.minus(min_increment)); | random_line_split |
btc-arbitrage.ts | TT.Factories.GDAX.FeedFactory(logger, products).then((feed: GDAXFeed) => {
// Configure all message streams to use the same websocket feed
// Create the source message streams by creating a MessageStream for each product, using the same WS feed for each
const streams = products.map((product) => new GTT.Core.ProductFilter({ logger: logger, productId: product }));
const outStream = new Array(products.length);
for (let i = 0; i < products.length; i++) {
outStream[i] = feed.pipe(streams[i]);
latest[i] = Big(-100000);
}
for (let i = 0; i < latest.length; i++) {
outStream[i].on('data', (msg: StreamMessage) => {
if (msg.type === 'trade') {
mangeTradeMessage(i, msg as TradeMessage);
}
if(msg.type !== 'level' && msg.type !== 'myOrderPlaced' && msg.type !== 'tradeExecuted' && msg.type !== 'tradeFinalized' && msg.type !== 'trade' && msg.type !== 'snapshot' && msg.type !== 'ticker' && msg.type !== 'unknown'){
console.log('Message Type: ' + msg.type)
}
if (msg.type === 'tradeExecuted') {//|| msg.type === 'tradeFinalized'){
console.log('Message Type: ' + msg.type)
process.stdout.write("\x07");
}
});
}
});
function mangeTradeMessage(index: number, msg: TradeMessage) {
let price = Big(msg.price);
// make the two exchange rates (ETH-BTC, LTC-BTC)relative to BTC-USD
if (products[index] === 'ETH-BTC' || products[index] === 'LTC-BTC'){
if (products[index] === 'ETH-BTC' ) {
latest_eth_btc_conversion = price;
}
let btc_usd = latest[BTC_USD_i];
if (btc_usd.gt(zero)) {
latest[index] = price.times(btc_usd);
}
// once this next line has run once you are all necessary infomation is in place to trade for the respective currency.
products[index] === 'ETH-BTC' ? ready[0] = true : ready[1] = true;
} else {
latest[index] = price;
}
// calculate the diff in prices between buying currency x in BTC vs USD
diff[0] = latest[ETH_USD_i].minus(latest[ETH_BTC_i]);
diff[1] = latest[LTC_USD_i].minus( latest[LTC_BTC_i]);
// if were not ready yet dont try to process the arbitrage.
if (!ready[0] || latest[ETH_BTC_i].lt(zero) || latest[ETH_USD_i].lt(zero) || latest[BTC_USD_i].lt(zero)) {
return
}
printUnderline(latest, index);
printLatestPrices(diff);
let randNumber = getRandomInt(0, 200);
if(randNumber != 10) {
// console.log(`skip order: ${randNumber}`);
return
}
process.stdout.write('🎯');
let eth_diff = diff[0];
processArbitrage(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
processArbitrage2(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
}
function printLatestPrices(prices: BigJS[]) {
// const cur = ['BTC-USD', 'ETH-BTC', 'LTC-BTC'];
const diffLabels = ['ETH', 'LTC'];
const pstr = diffLabels.map((c, i) => `${c} ${padfloat(prices[i], 6, 6)}`);
const msg = pstr.join(' | ');
// process.stdout.write(msg + ' | ');
console.log(' | ' + msg);
}
function printUnderline(prices: BigJS[], changeIndex: number) {
const pstr = products.map((c, i) => `${c}${i === changeIndex ? "\x1b[36m" : ""} ${padfloat(prices[i], 6, 6)} ${i === changeIndex ? "\x1b[0m" : ""}`);
const msg = pstr.join(' | ');
process.stdout.write(msg)
}
function ord | de: string, product: string, amount: string, price: string) {
const [base, quote] = product.split('-');
console.log(side + ' ' + base + ' ' + amount + ' ' + product + '@ ' + price);
const order: PlaceOrderMessage = {
time: new Date(),
type: 'placeOrder',
productId: product,
size: amount,
price: price,
side: side,
orderType: 'limit',
postOnly: true
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Order executed', `Order to ${order.side} ${amount} ${base} for ${price} ${quote} placed. Result: ${result.status}`);
processOrderResult(result, order)
}).catch(logError);
return order;
}
function orderMarketMessage(side: string, product: string, amount: string, price: string) {
console.log(side + ' ' + amount + ' ' + product + '@ ' + price + ' - ' + amount);
const [base, quote] = product.split('-');
const order: PlaceOrderMessage = {
type: 'order',
time: new Date(),
productId: product,
orderType: 'market',
side: side,
size: amount
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Market order executed ', `Order to ${order.side} ${amount} ${base} placed. Result: ${result.status}`);
});
return order;
}
let executedArbitrage = false;
function processArbitrage(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(1);
let min_increment = Big(0.01);
if (arbitrageValue.lte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lte(zero)) {return}
if (arbitrageValue.lt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
let buy_price = eth_btc;
let btc_min_amount = Big(0.01);
let amount = btc_min_amount.div(eth_btc); //0.01 / 0.04472 = 0.22361359
let sell_price = eth_price2.plus(min_increment);
let buy_price2 = btc_price.minus(min_increment);
let eth_needed = btc_min_amount.div(eth_btc);
let btc_needed = eth_btc.times(amount);
let usd_needed = btc_min_amount.times(btc_price.minus(min_increment));
console.log(`arbitrageValue: ${arbitrageValue}`);
sufficentBalances(btc_needed, eth_needed, usd_needed).then(result => {
if (!result) {
console.log('Insufficient Balances');
return
}
// alert me.
process.stdout.write("\x07");
// buy eth with bitcoin
orderMessageWithREST('buy', 'ETH-BTC', amount.toFixed(8), buy_price.toFixed(5));
console.log('buy ' + amount + ' eth @ ' + buy_price);
// sell eth for usd
orderMessageWithREST('sell', 'ETH-USD', amount.toFixed(8), sell_price.toFixed(2));
console.log('sell 0.01 eth for this many usd: ' + sell_price.toFixed(2));
// buy bitcoin with usd
orderMessageWithREST('buy', 'BTC-USD', `${btc_min_amount.toFixed(2)}`, buy_price2.toFixed(2));
console.log('buy bitcoin with usd: ' + buy_price2.toFixed(2));
executedArbitrage = true
});
executedArbitrage = true
}
function processArbitrage2(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(-1);
let min_increment = Big(0.01);
if (arbitrageValue.gte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lt(zero)) {return}
if (arbitrageValue.gt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
// i need 0.01 BTC
// I need 0.01 / btc_eth exchange rate
// I need 0.0 | erMessageWithREST(si | identifier_name |
btc-arbitrage.ts | TT.Factories.GDAX.FeedFactory(logger, products).then((feed: GDAXFeed) => {
// Configure all message streams to use the same websocket feed
// Create the source message streams by creating a MessageStream for each product, using the same WS feed for each
const streams = products.map((product) => new GTT.Core.ProductFilter({ logger: logger, productId: product }));
const outStream = new Array(products.length);
for (let i = 0; i < products.length; i++) {
outStream[i] = feed.pipe(streams[i]);
latest[i] = Big(-100000);
}
for (let i = 0; i < latest.length; i++) {
outStream[i].on('data', (msg: StreamMessage) => {
if (msg.type === 'trade') {
mangeTradeMessage(i, msg as TradeMessage);
}
if(msg.type !== 'level' && msg.type !== 'myOrderPlaced' && msg.type !== 'tradeExecuted' && msg.type !== 'tradeFinalized' && msg.type !== 'trade' && msg.type !== 'snapshot' && msg.type !== 'ticker' && msg.type !== 'unknown'){
console.log('Message Type: ' + msg.type)
}
if (msg.type === 'tradeExecuted') {//|| msg.type === 'tradeFinalized'){
console.log('Message Type: ' + msg.type)
process.stdout.write("\x07");
}
});
}
});
function mangeTradeMessage(index: number, msg: TradeMessage) {
let price = Big(msg.price);
// make the two exchange rates (ETH-BTC, LTC-BTC)relative to BTC-USD
if (products[index] === 'ETH-BTC' || products[index] === 'LTC-BTC'){
if (products[index] === 'ETH-BTC' ) {
latest_eth_btc_conversion = price;
}
let btc_usd = latest[BTC_USD_i];
if (btc_usd.gt(zero)) {
latest[index] = price.times(btc_usd);
}
// once this next line has run once you are all necessary infomation is in place to trade for the respective currency.
products[index] === 'ETH-BTC' ? ready[0] = true : ready[1] = true;
} else {
latest[index] = price;
}
// calculate the diff in prices between buying currency x in BTC vs USD
diff[0] = latest[ETH_USD_i].minus(latest[ETH_BTC_i]);
diff[1] = latest[LTC_USD_i].minus( latest[LTC_BTC_i]);
// if were not ready yet dont try to process the arbitrage.
if (!ready[0] || latest[ETH_BTC_i].lt(zero) || latest[ETH_USD_i].lt(zero) || latest[BTC_USD_i].lt(zero)) {
return
}
printUnderline(latest, index);
printLatestPrices(diff);
let randNumber = getRandomInt(0, 200);
if(randNumber != 10) {
// console.log(`skip order: ${randNumber}`);
return
}
process.stdout.write('🎯');
let eth_diff = diff[0];
processArbitrage(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
processArbitrage2(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
}
function printLatestPrices(prices: BigJS[]) {
// const cur = ['BTC-USD', 'ETH-BTC', 'LTC-BTC'];
const diffLabels = ['ETH', 'LTC'];
const pstr = diffLabels.map((c, i) => `${c} ${padfloat(prices[i], 6, 6)}`);
const msg = pstr.join(' | ');
// process.stdout.write(msg + ' | ');
console.log(' | ' + msg);
}
function printUnderline(prices: BigJS[], changeIndex: number) {
const pstr = products.map((c, i) => `${c}${i === changeIndex ? "\x1b[36m" : ""} ${padfloat(prices[i], 6, 6)} ${i === changeIndex ? "\x1b[0m" : ""}`);
const msg = pstr.join(' | ');
process.stdout.write(msg)
}
function orderMessageWithREST(side: string, product: string, amount: string, price: string) {
const [base, quote] = product.split('-');
console.log(side + ' ' + base + ' ' + amount + ' ' + product + '@ ' + price);
const order: PlaceOrderMessage = {
time: new Date(),
type: 'placeOrder',
productId: product,
size: amount,
price: price,
side: side,
orderType: 'limit',
postOnly: true
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Order executed', `Order to ${order.side} ${amount} ${base} for ${price} ${quote} placed. Result: ${result.status}`);
processOrderResult(result, order)
}).catch(logError);
return order;
}
function orderMarketMessage(side: string, product: string, amount: string, price: string) {
console.log(side + ' ' + amount + ' ' + product + '@ ' + price + ' - ' + amount);
const [base, quote] = product.split('-');
const order: PlaceOrderMessage = {
type: 'order',
time: new Date(),
productId: product,
orderType: 'market',
side: side,
size: amount
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Market order executed ', `Order to ${order.side} ${amount} ${base} placed. Result: ${result.status}`);
});
return order;
}
let executedArbitrage = false;
function processArbitrage(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(1);
let min_increment = Big(0.01);
if (arbitrageValue.lte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lte(zero)) {return}
if (arbitrageValue.lt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
let buy_price = eth_btc;
let btc_min_amount = Big(0.01);
let amount = btc_min_amount.div(eth_btc); //0.01 / 0.04472 = 0.22361359
let sell_price = eth_price2.plus(min_increment);
let buy_price2 = btc_price.minus(min_increment);
let eth_needed = btc_min_amount.div(eth_btc);
let btc_needed = eth_btc.times(amount);
let usd_needed = btc_min_amount.times(btc_price.minus(min_increment));
console.log(`arbitrageValue: ${arbitrageValue}`);
sufficentBalances(btc_needed, eth_needed, usd_needed).then(result => {
if (!result) {
console.log('Insufficient Balances');
return
}
// alert me.
process.stdout.write("\x07");
// buy eth with bitcoin
orderMessageWithREST('buy', 'ETH-BTC', amount.toFixed(8), buy_price.toFixed(5));
console.log('buy ' + amount + ' eth @ ' + buy_price);
// sell eth for usd
orderMessageWithREST('sell', 'ETH-USD', amount.toFixed(8), sell_price.toFixed(2));
console.log('sell 0.01 eth for this many usd: ' + sell_price.toFixed(2));
// buy bitcoin with usd
orderMessageWithREST('buy', 'BTC-USD', `${btc_min_amount.toFixed(2)}`, buy_price2.toFixed(2));
console.log('buy bitcoin with usd: ' + buy_price2.toFixed(2));
executedArbitrage = true
});
executedArbitrage = true
}
function processArbitrage2(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(-1);
let min_increment = Big(0.01);
if (arbitrageValue.gte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lt(zero)) {re | if (arbitrageValue.gt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
// i need 0.01 BTC
// I need 0.01 / btc_eth exchange rate
// I need 0.0 | turn}
| conditional_block |
btc-arbitrage.ts | 0; i < products.length; i++) {
outStream[i] = feed.pipe(streams[i]);
latest[i] = Big(-100000);
}
for (let i = 0; i < latest.length; i++) {
outStream[i].on('data', (msg: StreamMessage) => {
if (msg.type === 'trade') {
mangeTradeMessage(i, msg as TradeMessage);
}
if(msg.type !== 'level' && msg.type !== 'myOrderPlaced' && msg.type !== 'tradeExecuted' && msg.type !== 'tradeFinalized' && msg.type !== 'trade' && msg.type !== 'snapshot' && msg.type !== 'ticker' && msg.type !== 'unknown'){
console.log('Message Type: ' + msg.type)
}
if (msg.type === 'tradeExecuted') {//|| msg.type === 'tradeFinalized'){
console.log('Message Type: ' + msg.type)
process.stdout.write("\x07");
}
});
}
});
function mangeTradeMessage(index: number, msg: TradeMessage) {
let price = Big(msg.price);
// make the two exchange rates (ETH-BTC, LTC-BTC)relative to BTC-USD
if (products[index] === 'ETH-BTC' || products[index] === 'LTC-BTC'){
if (products[index] === 'ETH-BTC' ) {
latest_eth_btc_conversion = price;
}
let btc_usd = latest[BTC_USD_i];
if (btc_usd.gt(zero)) {
latest[index] = price.times(btc_usd);
}
// once this next line has run once you are all necessary infomation is in place to trade for the respective currency.
products[index] === 'ETH-BTC' ? ready[0] = true : ready[1] = true;
} else {
latest[index] = price;
}
// calculate the diff in prices between buying currency x in BTC vs USD
diff[0] = latest[ETH_USD_i].minus(latest[ETH_BTC_i]);
diff[1] = latest[LTC_USD_i].minus( latest[LTC_BTC_i]);
// if were not ready yet dont try to process the arbitrage.
if (!ready[0] || latest[ETH_BTC_i].lt(zero) || latest[ETH_USD_i].lt(zero) || latest[BTC_USD_i].lt(zero)) {
return
}
printUnderline(latest, index);
printLatestPrices(diff);
let randNumber = getRandomInt(0, 200);
if(randNumber != 10) {
// console.log(`skip order: ${randNumber}`);
return
}
process.stdout.write('🎯');
let eth_diff = diff[0];
processArbitrage(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
processArbitrage2(eth_diff, latest[ETH_BTC_i], latest[ETH_USD_i], latest[BTC_USD_i], latest_eth_btc_conversion);
}
function printLatestPrices(prices: BigJS[]) {
// const cur = ['BTC-USD', 'ETH-BTC', 'LTC-BTC'];
const diffLabels = ['ETH', 'LTC'];
const pstr = diffLabels.map((c, i) => `${c} ${padfloat(prices[i], 6, 6)}`);
const msg = pstr.join(' | ');
// process.stdout.write(msg + ' | ');
console.log(' | ' + msg);
}
function printUnderline(prices: BigJS[], changeIndex: number) {
const pstr = products.map((c, i) => `${c}${i === changeIndex ? "\x1b[36m" : ""} ${padfloat(prices[i], 6, 6)} ${i === changeIndex ? "\x1b[0m" : ""}`);
const msg = pstr.join(' | ');
process.stdout.write(msg)
}
function orderMessageWithREST(side: string, product: string, amount: string, price: string) {
const [base, quote] = product.split('-');
console.log(side + ' ' + base + ' ' + amount + ' ' + product + '@ ' + price);
const order: PlaceOrderMessage = {
time: new Date(),
type: 'placeOrder',
productId: product,
size: amount,
price: price,
side: side,
orderType: 'limit',
postOnly: true
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Order executed', `Order to ${order.side} ${amount} ${base} for ${price} ${quote} placed. Result: ${result.status}`);
processOrderResult(result, order)
}).catch(logError);
return order;
}
function orderMarketMessage(side: string, product: string, amount: string, price: string) {
console.log(side + ' ' + amount + ' ' + product + '@ ' + price + ' - ' + amount);
const [base, quote] = product.split('-');
const order: PlaceOrderMessage = {
type: 'order',
time: new Date(),
productId: product,
orderType: 'market',
side: side,
size: amount
};
gdaxAPI.placeOrder(order).then((result: LiveOrder) => {
console.log('Market order executed ', `Order to ${order.side} ${amount} ${base} placed. Result: ${result.status}`);
});
return order;
}
let executedArbitrage = false;
function processArbitrage(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
// arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(1);
let min_increment = Big(0.01);
if (arbitrageValue.lte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lte(zero)) {return}
if (arbitrageValue.lt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
let buy_price = eth_btc;
let btc_min_amount = Big(0.01);
let amount = btc_min_amount.div(eth_btc); //0.01 / 0.04472 = 0.22361359
let sell_price = eth_price2.plus(min_increment);
let buy_price2 = btc_price.minus(min_increment);
let eth_needed = btc_min_amount.div(eth_btc);
let btc_needed = eth_btc.times(amount);
let usd_needed = btc_min_amount.times(btc_price.minus(min_increment));
console.log(`arbitrageValue: ${arbitrageValue}`);
sufficentBalances(btc_needed, eth_needed, usd_needed).then(result => {
if (!result) {
console.log('Insufficient Balances');
return
}
// alert me.
process.stdout.write("\x07");
// buy eth with bitcoin
orderMessageWithREST('buy', 'ETH-BTC', amount.toFixed(8), buy_price.toFixed(5));
console.log('buy ' + amount + ' eth @ ' + buy_price);
// sell eth for usd
orderMessageWithREST('sell', 'ETH-USD', amount.toFixed(8), sell_price.toFixed(2));
console.log('sell 0.01 eth for this many usd: ' + sell_price.toFixed(2));
// buy bitcoin with usd
orderMessageWithREST('buy', 'BTC-USD', `${btc_min_amount.toFixed(2)}`, buy_price2.toFixed(2));
console.log('buy bitcoin with usd: ' + buy_price2.toFixed(2));
executedArbitrage = true
});
executedArbitrage = true
}
function processArbitrage2(arbitrageValue: BigJS, eth_price: BigJS, eth_price2: BigJS, btc_price: BigJS, eth_btc: BigJS) {
| // arbitrageValue = eth_price2 - eth_price
let arbitrageLimit = Big(-1);
let min_increment = Big(0.01);
if (arbitrageValue.gte(zero)) {return}
if (eth_btc.isZero() || eth_btc.lt(zero)) {return}
if (arbitrageValue.gt(arbitrageLimit)) {return}
// if (executedArbitrage === true) {return}
// i need 0.01 BTC
// I need 0.01 / btc_eth exchange rate
// I need 0.01 * btc_usd exchange rate
let buy_price = eth_btc;
let btc_min_amount = Big(0.01);
let amount = btc_min_amount.div(eth_btc); //0.01 / 0.04472 = 0.22361359
let sell_price = eth_price2.minus(min_increment);
let buy_price2 = btc_price.plus(min_increment);
let eth_needed = amount; | identifier_body | |
asset.rs | nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn ticker(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current asset name
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn name(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current version of the asset contract, represented in Ricardian form
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn ricardian_contract(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current decimal precision of the asset value
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn decimal_precision(&self) -> u8 {
*self.active_nomination().decimal_precision()
}
/// Returns information (in atomic value units) about specific measure of
/// the asset supply, if known, or `None` otherwise
pub fn precise_supply(
&self,
measure: SupplyMeasure,
) -> Option<AtomicValue> {
Some(match measure {
SupplyMeasure::KnownCirculating => *self.supply.known_circulating(),
SupplyMeasure::TotalCirculating => {
match self.supply.total_circulating() {
None => return None,
Some(supply) => supply,
}
}
SupplyMeasure::IssueLimit => *self.supply.issue_limit(),
})
}
/// Returns information in form of a float number about specific measure of
/// the asset supply, if known, or [`f64::NAN`] otherwise
pub fn fractional_supply(
&self,
measure: SupplyMeasure,
) -> FractionalAmount {
let value = match self.precise_supply(measure) {
None => return FractionalAmount::NAN,
Some(supply) => supply,
};
PreciseAmount::transmutate_into(value, self.decimal_precision())
}
/// Nomination resulting from the last known renomination
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn last_nomination(&self) -> Option<&Nomination> {
self.known_renominations.last().map(|o| o.nomination())
}
/// Active nomination data.
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn active_nomination(&self) -> &Nomination {
self.last_nomination().unwrap_or(&self.genesis_nomination)
}
/// Returns sum of all known allocations, in atomic value units
#[inline]
pub fn known_value(&self) -> AtomicValue {
self.known_allocations.iter().map(Allocation::value).sum()
}
/// Returns sum of known allocation after applying `filter` function. Useful
/// for filtering UTXOs owned by the current wallet. The returned value is
/// in atomic units (see [`AtomicValue`]
pub fn known_filtered_value<F>(&self, filter: F) -> AtomicValue
where
F: Fn(&Allocation) -> bool,
{
self.known_allocations
.iter()
.filter(|allocation| filter(*allocation))
.map(Allocation::value)
.sum()
}
/// Returns sum of all known allocations, as a floating point value (see
/// [`FractionalAmount`])
pub fn known_amount(&self) -> FractionalAmount {
self.known_allocations
.iter()
.map(Allocation::value)
.map(|atomic| {
PreciseAmount::transmutate_into(
atomic,
self.decimal_precision(),
)
})
.sum()
}
/// Returns sum of known allocation after applying `filter` function. Useful
/// for filtering UTXOs owned by the current wallet. The returned amount is
/// a floating point number (see [`FractionalAmount`])
pub fn known_filtered_amount<F>(&self, filter: F) -> FractionalAmount
where
F: Fn(&Allocation) -> bool,
{
self.known_allocations
.iter()
.filter(|allocation| filter(*allocation))
.map(Allocation::value)
.map(|atomic| {
PreciseAmount::transmutate_into(
atomic,
self.decimal_precision(),
)
})
.sum()
}
/// Returns outpoints which when spent may indicate inflation happening
/// up to specific amount.
///
/// NB: Not of all inflation controlling points may be known
pub fn known_inflation(
&self,
) -> BTreeMap<OutPoint, (AtomicValue, Vec<u16>)> {
let mut inflation_list = BTreeMap::new();
for issue in self.known_issues() {
for (seal, data) in issue.inflation_assignments() {
inflation_list.insert(*seal, data.clone());
}
}
inflation_list
}
#[inline]
/// Lists all known allocations for the given bitcoin transaction
/// [`OutPoint`]
pub fn outpoint_allocations(&self, outpoint: OutPoint) -> Vec<Allocation> {
self.known_allocations
.iter()
.filter(|a| *a.outpoint() == outpoint)
.copied()
.collect()
}
/// Adds new allocation to the list of known allocations
pub fn add_allocation(
&mut self,
outpoint: OutPoint,
node_id: NodeId,
index: u16,
value: value::Revealed,
) -> bool {
let new_allocation = Allocation::with(node_id, index, outpoint, value);
if !self.known_allocations.contains(&new_allocation) {
self.known_allocations.push(new_allocation);
true
} else {
false
}
}
/// Adds issue to the list of known issues. This is an internal function
/// which should not be used directly; instead construct the asset structure
/// from the [`Consignment`] using [`Asset::try_from`] method.
fn add_issue(
&mut self,
consignment: &Consignment,
transition: &Transition,
witness: Txid,
) -> Result<(), Error> {
let closed_seals = consignment.seals_closed_with(
transition.node_id(),
OwnedRightType::Inflation,
witness,
)?;
let issue = Issue::with(self.id, closed_seals, transition, witness)?;
self.known_issues.push(issue);
Ok(())
}
/// Adds an epoch to the list of known epochs. This is an internal function
/// which should not be used directly; instead construct the asset structure
/// from the [`Consignment`] using [`Asset::try_from`] method.
fn add_epoch(
&mut self,
consignment: &Consignment,
transition: &Transition,
no: usize,
operations: Vec<BurnReplace>,
witness: Txid,
) -> Result<(), Error> {
let id = transition.node_id();
// 1. It must correctly extend known state, i.e. close UTXO for a seal
// defined by a state transition already belonging to the asset
let closed_seal = consignment
.seals_closed_with(id, OwnedRightType::OpenEpoch, witness)?
.into_iter()
.next()
.ok_or(Error::Inconsistency(
rgb::ConsistencyError::NoSealsClosed(
OwnedRightType::OpenEpoch.into(),
id,
),
))?;
let epoch = Epoch::with(
self.id,
no,
closed_seal,
transition,
operations,
witness,
)?;
self.epochs.insert(no as usize, epoch);
Ok(())
}
}
impl TryFrom<Genesis> for Asset {
type Error = Error;
fn try_from(genesis: Genesis) -> Result<Self, Self::Error> {
if genesis.schema_id() != schema::schema().schema_id() {
Err(Error::WrongSchemaId)?;
}
let genesis_meta = genesis.metadata(); | random_line_split | ||
asset.rs | serde(crate = "serde_crate", rename_all = "camelCase")
)]
#[derive(
Clone, Getters, PartialEq, Debug, Display, StrictEncode, StrictDecode,
)]
#[display("{genesis_nomination} ({id})")]
pub struct Asset {
/// Bech32-representation of the asset genesis
genesis: String,
/// Asset ID, which is equal to Contract ID and genesis ID
///
/// It can be used as a unique primary kep
id: ContractId,
/// Chain with which the asset is issued
#[cfg_attr(feature = "serde", serde(with = "As::<DisplayFromStr>"))]
chain: Chain,
/// Asset creation data
date: DateTime<Utc>,
/// Names assigned to the asset at the issue time
///
/// Nomination is a set of asset metadata assigned by the issuer, which
/// define core asset properties: ticker, name, decimal precision, contract
/// text.
#[cfg_attr(feature = "serde", serde(flatten))]
genesis_nomination: Nomination,
/// List of all known renominations.
///
/// This list does not include genesis nomination, which can be accessed
/// via [`Asset::genesis_nomination`]. The last item in the list contains
/// [`Asset::last_nomination`] data as a part of its renomination operation
/// details.
known_renominations: Vec<Renomination>,
/// All issues known from the available data (stash and/or provided
/// consignments)
///
/// Primary issue is always the first one; the rest are provided in
/// arbitrary order
known_issues: Vec<Issue>,
/// Single-use-seal controlling the beginning of the first epoch
epoch_opening_seal: Option<OutPoint>,
/// Burn & replacement epochs, organized according to the witness txid.
///
/// Witness transaction must be mined for the epoch to be real.
/// One of the inputs of this transaction MUST spend UTXO defined as a
/// seal closed by this epoch ([`Epoch::closes`])
epochs: Vec<Epoch>,
/// Detailed information about the asset supply (aggregated from the issue
/// and burning information kept inside the epochs data)
#[cfg_attr(feature = "serde", serde(flatten))]
supply: Supply,
/// Specifies outpoints controlling certain amounts of assets.
///
/// NB: Information here does not imply that the outputs are owned by the
/// current user or the owning transactions are mined/exist; this must be
/// determined by the wallet and depends on specific medium (blockchain,
/// LN)
known_allocations: Vec<Allocation>,
}
impl Asset {
/// Current asset ticker
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn ticker(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current asset name
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn name | lf) -> &str {
&self.active_nomination().ticker()
}
/// Current version of the asset contract, represented in Ricardian form
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn ricardian_contract(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current decimal precision of the asset value
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn decimal_precision(&self) -> u8 {
*self.active_nomination().decimal_precision()
}
/// Returns information (in atomic value units) about specific measure of
/// the asset supply, if known, or `None` otherwise
pub fn precise_supply(
&self,
measure: SupplyMeasure,
) -> Option<AtomicValue> {
Some(match measure {
SupplyMeasure::KnownCirculating => *self.supply.known_circulating(),
SupplyMeasure::TotalCirculating => {
match self.supply.total_circulating() {
None => return None,
Some(supply) => supply,
}
}
SupplyMeasure::IssueLimit => *self.supply.issue_limit(),
})
}
/// Returns information in form of a float number about specific measure of
/// the asset supply, if known, or [`f64::NAN`] otherwise
pub fn fractional_supply(
&self,
measure: SupplyMeasure,
) -> FractionalAmount {
let value = match self.precise_supply(measure) {
None => return FractionalAmount::NAN,
Some(supply) => supply,
};
PreciseAmount::transmutate_into(value, self.decimal_precision())
}
/// Nomination resulting from the last known renomination
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn last_nomination(&self) -> Option<&Nomination> {
self.known_renominations.last().map(|o| o.nomination())
}
/// Active nomination data.
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn active_nomination(&self) -> &Nomination {
self.last_nomination().unwrap_or(&self.genesis_nomination)
}
/// Returns sum of all known allocations, in atomic value units
#[inline]
pub fn known_value(&self) -> AtomicValue {
self.known_allocations.iter().map(Allocation::value).sum()
}
/// Returns sum of known allocation after applying `filter` function. Useful
/// for filtering UTXOs owned by the current wallet. The returned value is
/// in atomic units (see [`AtomicValue`]
pub fn known_filtered_value<F>(&self, filter: F) -> AtomicValue
where
F: Fn(&Allocation) -> bool,
{
self.known_allocations
.iter()
.filter(|allocation| filter(*allocation))
.map(Allocation::value)
.sum()
}
/// Returns sum of all known allocations, as a floating point value (see
/// [`FractionalAmount`])
pub fn known_amount(&self) -> FractionalAmount {
self.known_allocations
.iter()
.map(Allocation::value)
.map(|atomic| {
PreciseAmount::transmutate_into(
atomic,
self.decimal_precision(),
)
})
.sum()
}
/// Returns sum of known allocation after applying `filter` function. Useful
/// for filtering UTXOs owned by the current wallet. The returned amount is
/// a floating point number (see [`FractionalAmount`])
pub fn known_filtered_amount<F>(&self, filter: F) -> FractionalAmount
where
F: Fn(&Allocation) -> bool,
{
self.known_allocations
.iter()
.filter(|allocation| filter(*allocation))
.map(Allocation::value)
.map(|atomic| {
PreciseAmount::transmutate_into(
atomic,
self.decimal_precision(),
)
})
.sum()
}
/// Returns outpoints which when spent may indicate inflation happening
/// up to specific amount.
///
/// NB: Not of all inflation controlling points may be known
pub fn known_inflation(
&self,
) -> BTreeMap<OutPoint, (AtomicValue, Vec<u16>)> {
let mut inflation_list = BTreeMap::new();
for issue in self.known_issues() {
for (seal, data) in issue.inflation_assignments() {
inflation_list.insert(*seal, data.clone());
}
}
inflation_list
}
#[inline]
/// Lists all known allocations for the given bitcoin transaction
/// [`OutPoint`]
pub fn outpoint_allocations(&self, outpoint: OutPoint) -> Vec | (&se | identifier_name |
asset.rs | serde(crate = "serde_crate", rename_all = "camelCase")
)]
#[derive(
Clone, Getters, PartialEq, Debug, Display, StrictEncode, StrictDecode,
)]
#[display("{genesis_nomination} ({id})")]
pub struct Asset {
/// Bech32-representation of the asset genesis
genesis: String,
/// Asset ID, which is equal to Contract ID and genesis ID
///
/// It can be used as a unique primary kep
id: ContractId,
/// Chain with which the asset is issued
#[cfg_attr(feature = "serde", serde(with = "As::<DisplayFromStr>"))]
chain: Chain,
/// Asset creation data
date: DateTime<Utc>,
/// Names assigned to the asset at the issue time
///
/// Nomination is a set of asset metadata assigned by the issuer, which
/// define core asset properties: ticker, name, decimal precision, contract
/// text.
#[cfg_attr(feature = "serde", serde(flatten))]
genesis_nomination: Nomination,
/// List of all known renominations.
///
/// This list does not include genesis nomination, which can be accessed
/// via [`Asset::genesis_nomination`]. The last item in the list contains
/// [`Asset::last_nomination`] data as a part of its renomination operation
/// details.
known_renominations: Vec<Renomination>,
/// All issues known from the available data (stash and/or provided
/// consignments)
///
/// Primary issue is always the first one; the rest are provided in
/// arbitrary order
known_issues: Vec<Issue>,
/// Single-use-seal controlling the beginning of the first epoch
epoch_opening_seal: Option<OutPoint>,
/// Burn & replacement epochs, organized according to the witness txid.
///
/// Witness transaction must be mined for the epoch to be real.
/// One of the inputs of this transaction MUST spend UTXO defined as a
/// seal closed by this epoch ([`Epoch::closes`])
epochs: Vec<Epoch>,
/// Detailed information about the asset supply (aggregated from the issue
/// and burning information kept inside the epochs data)
#[cfg_attr(feature = "serde", serde(flatten))]
supply: Supply,
/// Specifies outpoints controlling certain amounts of assets.
///
/// NB: Information here does not imply that the outputs are owned by the
/// current user or the owning transactions are mined/exist; this must be
/// determined by the wallet and depends on specific medium (blockchain,
/// LN)
known_allocations: Vec<Allocation>,
}
impl Asset {
/// Current asset ticker
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn ticker(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current asset name
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn name(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current version of the asset contract, represented in Ricardian form
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn ricardian_contract(&self) -> &str {
&self.active_nomination().ticker()
}
/// Current decimal precision of the asset value
///
/// Current value determined by the last known renomination operation –
/// or, by the genesis nomination, if no renomination are known
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn decimal_precision(&self) -> u8 {
*self.active_nomination().decimal_precision()
}
/// Returns information (in atomic value units) about specific measure of
/// the asset supply, if known, or `None` otherwise
pub fn precise_supply(
&self,
measure: SupplyMeasure,
) -> Option<AtomicValue> {
Some(match measure {
SupplyMeasure::KnownCirculating => *self.supply.known_circulating(),
SupplyMeasure::TotalCirculating => {
match self.supply.total_circulating() {
None => return None,
Some(supply) => supply,
}
}
SupplyMeasure::IssueLimit => *self.supply.issue_limit(),
})
}
/// Returns information in form of a float number about specific measure of
/// the asset supply, if known, or [`f64::NAN`] otherwise
pub fn fractional_supply(
&self,
measure: SupplyMeasure,
) -> FractionalAmount {
let value = match self.precise_supply(measure) {
None => return FractionalAmount::NAN,
Some(supply) => supply,
};
PreciseAmount::transmutate_into(value, self.decimal_precision())
}
/// Nomination resulting from the last known renomination
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn last_nomination(&self) -> Option<&Nomination> {
self.known_renominations.last().map(|o| o.nomination())
}
/// Active nomination data.
///
/// NB: the returned result may not match the current valid nomination,
/// since if there were further not yet known nominations the value
/// returned by this function will not match the valid data
#[inline]
pub fn active_nomination(&self) -> &Nomination {
| / Returns sum of all known allocations, in atomic value units
#[inline]
pub fn known_value(&self) -> AtomicValue {
self.known_allocations.iter().map(Allocation::value).sum()
}
/// Returns sum of known allocation after applying `filter` function. Useful
/// for filtering UTXOs owned by the current wallet. The returned value is
/// in atomic units (see [`AtomicValue`]
pub fn known_filtered_value<F>(&self, filter: F) -> AtomicValue
where
F: Fn(&Allocation) -> bool,
{
self.known_allocations
.iter()
.filter(|allocation| filter(*allocation))
.map(Allocation::value)
.sum()
}
/// Returns sum of all known allocations, as a floating point value (see
/// [`FractionalAmount`])
pub fn known_amount(&self) -> FractionalAmount {
self.known_allocations
.iter()
.map(Allocation::value)
.map(|atomic| {
PreciseAmount::transmutate_into(
atomic,
self.decimal_precision(),
)
})
.sum()
}
/// Returns sum of known allocation after applying `filter` function. Useful
/// for filtering UTXOs owned by the current wallet. The returned amount is
/// a floating point number (see [`FractionalAmount`])
pub fn known_filtered_amount<F>(&self, filter: F) -> FractionalAmount
where
F: Fn(&Allocation) -> bool,
{
self.known_allocations
.iter()
.filter(|allocation| filter(*allocation))
.map(Allocation::value)
.map(|atomic| {
PreciseAmount::transmutate_into(
atomic,
self.decimal_precision(),
)
})
.sum()
}
/// Returns outpoints which when spent may indicate inflation happening
/// up to specific amount.
///
/// NB: Not of all inflation controlling points may be known
pub fn known_inflation(
&self,
) -> BTreeMap<OutPoint, (AtomicValue, Vec<u16>)> {
let mut inflation_list = BTreeMap::new();
for issue in self.known_issues() {
for (seal, data) in issue.inflation_assignments() {
inflation_list.insert(*seal, data.clone());
}
}
inflation_list
}
#[inline]
/// Lists all known allocations for the given bitcoin transaction
/// [`OutPoint`]
pub fn outpoint_allocations(&self, outpoint: OutPoint) -> Vec | self.last_nomination().unwrap_or(&self.genesis_nomination)
}
// | identifier_body |
csv_import_accts_txns.rs | transactions_map,
)?;
Ok(())
}
fn import_accounts(
rdr: &mut csv::Reader<File>,
raw_acct_map: &mut HashMap<u16, RawAccount>,
acct_map: &mut HashMap<u16, Account>,
) -> Result<(), Box<dyn Error>> {
let header1 = rdr.headers()?.clone(); // account_num
let mut header2: csv::StringRecord = csv::StringRecord::new(); // name
let mut header3: csv::StringRecord = csv::StringRecord::new(); // ticker
let header4: csv::StringRecord; // is_margin
// Account Creation loop. With rdr.has_headers() set to true above, the first record here is the second row of the CSV
for result in rdr.records() {
// This initial iteration through records will break after the 4th row, after accounts have been created
let record = result?;
if header2.len() == 0 {
header2 = record.clone();
continue // After header2 is set, continue to next record
}
else if header3.len() == 0 {
header3 = record.clone();
continue // After header3 is set, continue to next record
}
else {
header4 = record.clone();
// println!("Assigned last header, record: {:?}", record);
| // A StringRecord doesn't accept the same range indexing needed below, so a Vec of Strings will be used
let headerstrings: Vec<String> = header1.into_iter().map(|field| field.to_string()).collect();
let acct_num_warn = "Transactions will not import correctly if account numbers in the CSV import file aren't
ordered chronologically (i.e., beginning in column 4 - the 1st account column - the value should be 1.
The next column's value should be 2, then 3, etc, until the final account).";
// Header row variables have been set. It's now time to set up the accounts.
println!("\nCreating accounts...");
let length = &headerstrings.len();
for (idx, field) in headerstrings[3..*length].iter().enumerate() {
// Parse account numbers.
let account_num = field.trim().parse::<u16>().expect(&format!("Header row account number should parse into u16: {}", field));
// For now, their columns aren't remembered. Instead, they must have a particular index. 0th idx is the 1st account, and so on.
if account_num != ((idx + 1) as u16) {
println!("FATAL: CSV Import: {}", acct_num_warn);
std::process::exit(1);
}
let ind = idx+3; // Add three because the idx skips the first three 'key' columns
let name:String = header2[ind].trim().to_string();
let ticker:String = header3[ind].trim().to_string(); // no .to_uppercase() b/c margin...
let margin_string = &header4.clone()[ind];
let is_margin:bool = match margin_string.to_lowercase().trim() {
"no" | "non" | "false" => false,
"yes" | "margin" | "true" => true,
_ => {
println!("\n FATAL: CSV Import: Couldn't parse margin value for account {} {} \n",account_num, name);
process::exit(1)
}
};
let just_account: RawAccount = RawAccount {
account_num,
name,
ticker,
is_margin,
};
raw_acct_map.insert(account_num, just_account);
let account: Account = Account {
raw_key: account_num,
list_of_lots: RefCell::new([].to_vec())
};
acct_map.insert(account_num, account);
}
break // This `break` exits this scope so `accounts` can be accessed in `import_transactions`. The rdr stays put.
}
};
Ok(())
}
fn import_transactions(
rdr: &mut csv::Reader<File>,
iso_date_style: bool,
separator: &String,
action_records: &mut HashMap<u32, ActionRecord>,
txns_map: &mut HashMap<u32, Transaction>,
) -> Result<(), Box<dyn Error>> {
let mut this_tx_number = 0;
let mut this_ar_number = 0;
let mut changed_action_records = 0;
let mut changed_txn_num = Vec::new();
println!("Creating transactions...");
for result in rdr.records() {
// rdr's cursor is at row 5, which is the first transaction row
let record = result?;
this_tx_number += 1;
// First, initialize metadata fields.
let mut this_tx_date: &str = "";
let mut this_proceeds: &str;
let mut this_memo: &str = "";
let mut proceeds_parsed = 0f32;
// Next, create action_records.
let mut action_records_map_keys_vec: Vec<u32> = Vec::with_capacity(2);
let mut outgoing_ar: Option<ActionRecord> = None;
let mut incoming_ar: Option<ActionRecord> = None;
let mut outgoing_ar_num: Option<u32> = None;
let mut incoming_ar_num: Option<u32> = None;
for (idx, field) in record.iter().enumerate() {
// Set metadata fields on first three fields.
if idx == 0 { this_tx_date = field; }
else if idx == 1 {
let no_comma_string = field.replace(",", "");
proceeds_parsed = no_comma_string.parse::<f32>()?;
}
else if idx == 2 { this_memo = field; }
// Check for empty strings. If not empty, it's a value for an action_record.
else if field != "" {
this_ar_number += 1;
let ind = idx; // starts at 3, which is the fourth field
let acct_idx = ind - 2; // acct_num and acct_key would be idx + 1, so subtract 2 from ind to get 1
let account_key = acct_idx as u16;
let amount_str = field.replace(",", "");
let mut amount = amount_str.parse::<d128>().unwrap();
// When parsing to a d128, it won't error; rather it'll return a NaN. It must now check for NaN,
// and, if found, attempt to sanitize. These checks will convert accounting/comma format to the expected
// format by removing parentheses from negatives and adding a minus sign in the front. It will also
// attempt to remove empty spaces and currency symbols or designations (e.g. $ or USD).
if amount.is_nan() {
let b = sanitize_string_for_d128_parsing_basic(field).parse::<d128>().unwrap();
amount = b;
};
if amount.is_nan() {
let c = sanitize_string_for_d128_parsing_full(field).parse::<d128>().unwrap();
amount = c;
};
if amount.is_nan() {
println!("FATAL: Couldn't convert amount to d128 for transaction:\n{:#?}", record);
std::process::exit(1);
}
let amount_rounded = round_d128_1e8(&amount);
if amount != amount_rounded { changed_action_records += 1; changed_txn_num.push(this_tx_number); }
let action_record = ActionRecord {
account_key,
amount: amount_rounded,
tx_key: this_tx_number,
self_ar_key: this_ar_number,
movements: RefCell::new([].to_vec()),
};
if amount > d128!(0.0) {
incoming_ar = Some(action_record);
incoming_ar_num = Some(this_ar_number);
action_records_map_keys_vec.push(incoming_ar_num.unwrap())
} else {
outgoing_ar = Some(action_record);
outgoing_ar_num = Some(this_ar_number);
action_records_map_keys_vec.insert(0, outgoing_ar_num.unwrap())
};
}
}
// Note: the rust Trait implementation of FromStr for f32 is capable of parsing:
// '3.14'
// '-3.14'
// '2.5E10', or equivalently, '2.5e10'
// '2.5E-10'
// '5.'
// '.5', or, equivalently, '0.5'
// 'inf', '-inf', 'NaN'
// Notable observations from the list:
// (a) scientific notation is accepted
// (b) accounting format (numbers in parens representing negative numbers) is not explicitly accepted
// Additionally notable:
// (a) the decimal separator must be a period
// (b) there can be no commas
// (c) there can be no currency info ($120 or 120USD, etc. will fail to parse)
// In summary, it appears to only allow: (i) numeric chars, (ii) a period, and/or (iii) a minus sign
//
// The Decimal::d128 implementation of FromStr calls into a C library, and that lib hasn't
// been reviewed (by me | random_line_split | |
csv_import_accts_txns.rs | >,
) -> Result<(), Box<dyn Error>> {
let header1 = rdr.headers()?.clone(); // account_num
let mut header2: csv::StringRecord = csv::StringRecord::new(); // name
let mut header3: csv::StringRecord = csv::StringRecord::new(); // ticker
let header4: csv::StringRecord; // is_margin
// Account Creation loop. With rdr.has_headers() set to true above, the first record here is the second row of the CSV
for result in rdr.records() {
// This initial iteration through records will break after the 4th row, after accounts have been created
let record = result?;
if header2.len() == 0 {
header2 = record.clone();
continue // After header2 is set, continue to next record
}
else if header3.len() == 0 {
header3 = record.clone();
continue // After header3 is set, continue to next record
}
else {
header4 = record.clone();
// println!("Assigned last header, record: {:?}", record);
// A StringRecord doesn't accept the same range indexing needed below, so a Vec of Strings will be used
let headerstrings: Vec<String> = header1.into_iter().map(|field| field.to_string()).collect();
let acct_num_warn = "Transactions will not import correctly if account numbers in the CSV import file aren't
ordered chronologically (i.e., beginning in column 4 - the 1st account column - the value should be 1.
The next column's value should be 2, then 3, etc, until the final account).";
// Header row variables have been set. It's now time to set up the accounts.
println!("\nCreating accounts...");
let length = &headerstrings.len();
for (idx, field) in headerstrings[3..*length].iter().enumerate() {
// Parse account numbers.
let account_num = field.trim().parse::<u16>().expect(&format!("Header row account number should parse into u16: {}", field));
// For now, their columns aren't remembered. Instead, they must have a particular index. 0th idx is the 1st account, and so on.
if account_num != ((idx + 1) as u16) {
println!("FATAL: CSV Import: {}", acct_num_warn);
std::process::exit(1);
}
let ind = idx+3; // Add three because the idx skips the first three 'key' columns
let name:String = header2[ind].trim().to_string();
let ticker:String = header3[ind].trim().to_string(); // no .to_uppercase() b/c margin...
let margin_string = &header4.clone()[ind];
let is_margin:bool = match margin_string.to_lowercase().trim() {
"no" | "non" | "false" => false,
"yes" | "margin" | "true" => true,
_ => {
println!("\n FATAL: CSV Import: Couldn't parse margin value for account {} {} \n",account_num, name);
process::exit(1)
}
};
let just_account: RawAccount = RawAccount {
account_num,
name,
ticker,
is_margin,
};
raw_acct_map.insert(account_num, just_account);
let account: Account = Account {
raw_key: account_num,
list_of_lots: RefCell::new([].to_vec())
};
acct_map.insert(account_num, account);
}
break // This `break` exits this scope so `accounts` can be accessed in `import_transactions`. The rdr stays put.
}
};
Ok(())
}
fn import_transactions(
rdr: &mut csv::Reader<File>,
iso_date_style: bool,
separator: &String,
action_records: &mut HashMap<u32, ActionRecord>,
txns_map: &mut HashMap<u32, Transaction>,
) -> Result<(), Box<dyn Error>> {
let mut this_tx_number = 0;
let mut this_ar_number = 0;
let mut changed_action_records = 0;
let mut changed_txn_num = Vec::new();
println!("Creating transactions...");
for result in rdr.records() {
// rdr's cursor is at row 5, which is the first transaction row
let record = result?;
this_tx_number += 1;
// First, initialize metadata fields.
let mut this_tx_date: &str = "";
let mut this_proceeds: &str;
let mut this_memo: &str = "";
let mut proceeds_parsed = 0f32;
// Next, create action_records.
let mut action_records_map_keys_vec: Vec<u32> = Vec::with_capacity(2);
let mut outgoing_ar: Option<ActionRecord> = None;
let mut incoming_ar: Option<ActionRecord> = None;
let mut outgoing_ar_num: Option<u32> = None;
let mut incoming_ar_num: Option<u32> = None;
for (idx, field) in record.iter().enumerate() {
// Set metadata fields on first three fields.
if idx == 0 { this_tx_date = field; }
else if idx == 1 {
let no_comma_string = field.replace(",", "");
proceeds_parsed = no_comma_string.parse::<f32>()?;
}
else if idx == 2 { this_memo = field; }
// Check for empty strings. If not empty, it's a value for an action_record.
else if field != "" {
this_ar_number += 1;
let ind = idx; // starts at 3, which is the fourth field
let acct_idx = ind - 2; // acct_num and acct_key would be idx + 1, so subtract 2 from ind to get 1
let account_key = acct_idx as u16;
let amount_str = field.replace(",", "");
let mut amount = amount_str.parse::<d128>().unwrap();
// When parsing to a d128, it won't error; rather it'll return a NaN. It must now check for NaN,
// and, if found, attempt to sanitize. These checks will convert accounting/comma format to the expected
// format by removing parentheses from negatives and adding a minus sign in the front. It will also
// attempt to remove empty spaces and currency symbols or designations (e.g. $ or USD).
if amount.is_nan() {
let b = sanitize_string_for_d128_parsing_basic(field).parse::<d128>().unwrap();
amount = b;
};
if amount.is_nan() {
let c = sanitize_string_for_d128_parsing_full(field).parse::<d128>().unwrap();
amount = c;
};
if amount.is_nan() {
println!("FATAL: Couldn't convert amount to d128 for transaction:\n{:#?}", record);
std::process::exit(1);
}
let amount_rounded = round_d128_1e8(&amount);
if amount != amount_rounded { changed_action_records += 1; changed_txn_num.push(this_tx_number); }
let action_record = ActionRecord {
account_key,
amount: amount_rounded,
tx_key: this_tx_number,
self_ar_key: this_ar_number,
movements: RefCell::new([].to_vec()),
};
if amount > d128!(0.0) {
incoming_ar = Some(action_record);
incoming_ar_num = Some(this_ar_number);
action_records_map_keys_vec.push(incoming_ar_num.unwrap())
} else {
outgoing_ar = Some(action_record);
outgoing_ar_num = Some(this_ar_number);
action_records_map_keys_vec.insert(0, outgoing_ar_num.unwrap())
};
}
}
// Note: the rust Trait implementation of FromStr for f32 is capable of parsing:
// '3.14'
// '-3.14'
// '2.5E10', or equivalently, '2.5e10'
// '2.5E-10'
// '5.'
// '.5', or, equivalently, '0.5'
// 'inf', '-inf', 'NaN'
// Notable observations from the list:
// (a) scientific notation is accepted
// (b) accounting format (numbers in parens representing negative numbers) is not explicitly accepted
// Additionally notable:
// (a) the decimal separator must be a period
// (b) there can be no commas
// (c) there can be no currency info ($120 or 120USD, etc. will fail to parse)
// In summary, it appears to only allow: (i) numeric chars, (ii) a period, and/or (iii) a minus sign
//
// The Decimal::d128 implementation of FromStr calls into a C library, and that lib hasn't
// been reviewed (by me), but it is thought/hoped to follow similar parsing conventions,
// though there's no guarantee. Nevertheless, the above notes *appear* to hold true for d128.
fn | sanitize_string_for_d128_parsing_basic | identifier_name | |
csv_import_accts_txns.rs | 1.into_iter().map(|field| field.to_string()).collect();
let acct_num_warn = "Transactions will not import correctly if account numbers in the CSV import file aren't
ordered chronologically (i.e., beginning in column 4 - the 1st account column - the value should be 1.
The next column's value should be 2, then 3, etc, until the final account).";
// Header row variables have been set. It's now time to set up the accounts.
println!("\nCreating accounts...");
let length = &headerstrings.len();
for (idx, field) in headerstrings[3..*length].iter().enumerate() {
// Parse account numbers.
let account_num = field.trim().parse::<u16>().expect(&format!("Header row account number should parse into u16: {}", field));
// For now, their columns aren't remembered. Instead, they must have a particular index. 0th idx is the 1st account, and so on.
if account_num != ((idx + 1) as u16) {
println!("FATAL: CSV Import: {}", acct_num_warn);
std::process::exit(1);
}
let ind = idx+3; // Add three because the idx skips the first three 'key' columns
let name:String = header2[ind].trim().to_string();
let ticker:String = header3[ind].trim().to_string(); // no .to_uppercase() b/c margin...
let margin_string = &header4.clone()[ind];
let is_margin:bool = match margin_string.to_lowercase().trim() {
"no" | "non" | "false" => false,
"yes" | "margin" | "true" => true,
_ => {
println!("\n FATAL: CSV Import: Couldn't parse margin value for account {} {} \n",account_num, name);
process::exit(1)
}
};
let just_account: RawAccount = RawAccount {
account_num,
name,
ticker,
is_margin,
};
raw_acct_map.insert(account_num, just_account);
let account: Account = Account {
raw_key: account_num,
list_of_lots: RefCell::new([].to_vec())
};
acct_map.insert(account_num, account);
}
break // This `break` exits this scope so `accounts` can be accessed in `import_transactions`. The rdr stays put.
}
};
Ok(())
}
fn import_transactions(
rdr: &mut csv::Reader<File>,
iso_date_style: bool,
separator: &String,
action_records: &mut HashMap<u32, ActionRecord>,
txns_map: &mut HashMap<u32, Transaction>,
) -> Result<(), Box<dyn Error>> {
let mut this_tx_number = 0;
let mut this_ar_number = 0;
let mut changed_action_records = 0;
let mut changed_txn_num = Vec::new();
println!("Creating transactions...");
for result in rdr.records() {
// rdr's cursor is at row 5, which is the first transaction row
let record = result?;
this_tx_number += 1;
// First, initialize metadata fields.
let mut this_tx_date: &str = "";
let mut this_proceeds: &str;
let mut this_memo: &str = "";
let mut proceeds_parsed = 0f32;
// Next, create action_records.
let mut action_records_map_keys_vec: Vec<u32> = Vec::with_capacity(2);
let mut outgoing_ar: Option<ActionRecord> = None;
let mut incoming_ar: Option<ActionRecord> = None;
let mut outgoing_ar_num: Option<u32> = None;
let mut incoming_ar_num: Option<u32> = None;
for (idx, field) in record.iter().enumerate() {
// Set metadata fields on first three fields.
if idx == 0 { this_tx_date = field; }
else if idx == 1 {
let no_comma_string = field.replace(",", "");
proceeds_parsed = no_comma_string.parse::<f32>()?;
}
else if idx == 2 { this_memo = field; }
// Check for empty strings. If not empty, it's a value for an action_record.
else if field != "" {
this_ar_number += 1;
let ind = idx; // starts at 3, which is the fourth field
let acct_idx = ind - 2; // acct_num and acct_key would be idx + 1, so subtract 2 from ind to get 1
let account_key = acct_idx as u16;
let amount_str = field.replace(",", "");
let mut amount = amount_str.parse::<d128>().unwrap();
// When parsing to a d128, it won't error; rather it'll return a NaN. It must now check for NaN,
// and, if found, attempt to sanitize. These checks will convert accounting/comma format to the expected
// format by removing parentheses from negatives and adding a minus sign in the front. It will also
// attempt to remove empty spaces and currency symbols or designations (e.g. $ or USD).
if amount.is_nan() {
let b = sanitize_string_for_d128_parsing_basic(field).parse::<d128>().unwrap();
amount = b;
};
if amount.is_nan() {
let c = sanitize_string_for_d128_parsing_full(field).parse::<d128>().unwrap();
amount = c;
};
if amount.is_nan() {
println!("FATAL: Couldn't convert amount to d128 for transaction:\n{:#?}", record);
std::process::exit(1);
}
let amount_rounded = round_d128_1e8(&amount);
if amount != amount_rounded { changed_action_records += 1; changed_txn_num.push(this_tx_number); }
let action_record = ActionRecord {
account_key,
amount: amount_rounded,
tx_key: this_tx_number,
self_ar_key: this_ar_number,
movements: RefCell::new([].to_vec()),
};
if amount > d128!(0.0) {
incoming_ar = Some(action_record);
incoming_ar_num = Some(this_ar_number);
action_records_map_keys_vec.push(incoming_ar_num.unwrap())
} else {
outgoing_ar = Some(action_record);
outgoing_ar_num = Some(this_ar_number);
action_records_map_keys_vec.insert(0, outgoing_ar_num.unwrap())
};
}
}
// Note: the rust Trait implementation of FromStr for f32 is capable of parsing:
// '3.14'
// '-3.14'
// '2.5E10', or equivalently, '2.5e10'
// '2.5E-10'
// '5.'
// '.5', or, equivalently, '0.5'
// 'inf', '-inf', 'NaN'
// Notable observations from the list:
// (a) scientific notation is accepted
// (b) accounting format (numbers in parens representing negative numbers) is not explicitly accepted
// Additionally notable:
// (a) the decimal separator must be a period
// (b) there can be no commas
// (c) there can be no currency info ($120 or 120USD, etc. will fail to parse)
// In summary, it appears to only allow: (i) numeric chars, (ii) a period, and/or (iii) a minus sign
//
// The Decimal::d128 implementation of FromStr calls into a C library, and that lib hasn't
// been reviewed (by me), but it is thought/hoped to follow similar parsing conventions,
// though there's no guarantee. Nevertheless, the above notes *appear* to hold true for d128.
fn sanitize_string_for_d128_parsing_basic(field: &str) -> String {
// First, remove commas.
let no_comma_string = field.replace(",", "");
let almost_done = no_comma_string.replace(" ", "");
// Next, if ASCII (better be), check for accounting formatting
if almost_done.is_ascii() {
if almost_done.as_bytes()[0] == "(".as_bytes()[0] {
let half_fixed = almost_done.replace("(", "-");
let negative_with_minus = half_fixed.replace(")", "");
return negative_with_minus
}
}
almost_done
}
fn sanitize_string_for_d128_parsing_full(field: &str) -> String | {
let mut near_done = "".to_string();
// First, remove commas.
let no_comma_string = field.replace(",", "");
let almost_done = no_comma_string.replace(" ", "");
// Next, if ASCII (better be), check for accounting formating
if almost_done.is_ascii() {
if almost_done.as_bytes()[0] == "(".as_bytes()[0] {
let half_fixed = almost_done.replace("(", "-");
let negative_with_minus = half_fixed.replace(")", "");
near_done = negative_with_minus;
} else {
near_done = almost_done;
}
} else {
near_done = almost_done;
}
| identifier_body | |
csv_import_accts_txns.rs | _map,
)?;
Ok(())
}
fn import_accounts(
rdr: &mut csv::Reader<File>,
raw_acct_map: &mut HashMap<u16, RawAccount>,
acct_map: &mut HashMap<u16, Account>,
) -> Result<(), Box<dyn Error>> {
let header1 = rdr.headers()?.clone(); // account_num
let mut header2: csv::StringRecord = csv::StringRecord::new(); // name
let mut header3: csv::StringRecord = csv::StringRecord::new(); // ticker
let header4: csv::StringRecord; // is_margin
// Account Creation loop. With rdr.has_headers() set to true above, the first record here is the second row of the CSV
for result in rdr.records() {
// This initial iteration through records will break after the 4th row, after accounts have been created
let record = result?;
if header2.len() == 0 {
header2 = record.clone();
continue // After header2 is set, continue to next record
}
else if header3.len() == 0 {
header3 = record.clone();
continue // After header3 is set, continue to next record
}
else {
header4 = record.clone();
// println!("Assigned last header, record: {:?}", record);
// A StringRecord doesn't accept the same range indexing needed below, so a Vec of Strings will be used
let headerstrings: Vec<String> = header1.into_iter().map(|field| field.to_string()).collect();
let acct_num_warn = "Transactions will not import correctly if account numbers in the CSV import file aren't
ordered chronologically (i.e., beginning in column 4 - the 1st account column - the value should be 1.
The next column's value should be 2, then 3, etc, until the final account).";
// Header row variables have been set. It's now time to set up the accounts.
println!("\nCreating accounts...");
let length = &headerstrings.len();
for (idx, field) in headerstrings[3..*length].iter().enumerate() {
// Parse account numbers.
let account_num = field.trim().parse::<u16>().expect(&format!("Header row account number should parse into u16: {}", field));
// For now, their columns aren't remembered. Instead, they must have a particular index. 0th idx is the 1st account, and so on.
if account_num != ((idx + 1) as u16) {
println!("FATAL: CSV Import: {}", acct_num_warn);
std::process::exit(1);
}
let ind = idx+3; // Add three because the idx skips the first three 'key' columns
let name:String = header2[ind].trim().to_string();
let ticker:String = header3[ind].trim().to_string(); // no .to_uppercase() b/c margin...
let margin_string = &header4.clone()[ind];
let is_margin:bool = match margin_string.to_lowercase().trim() {
"no" | "non" | "false" => false,
"yes" | "margin" | "true" => true,
_ => {
println!("\n FATAL: CSV Import: Couldn't parse margin value for account {} {} \n",account_num, name);
process::exit(1)
}
};
let just_account: RawAccount = RawAccount {
account_num,
name,
ticker,
is_margin,
};
raw_acct_map.insert(account_num, just_account);
let account: Account = Account {
raw_key: account_num,
list_of_lots: RefCell::new([].to_vec())
};
acct_map.insert(account_num, account);
}
break // This `break` exits this scope so `accounts` can be accessed in `import_transactions`. The rdr stays put.
}
};
Ok(())
}
fn import_transactions(
rdr: &mut csv::Reader<File>,
iso_date_style: bool,
separator: &String,
action_records: &mut HashMap<u32, ActionRecord>,
txns_map: &mut HashMap<u32, Transaction>,
) -> Result<(), Box<dyn Error>> {
let mut this_tx_number = 0;
let mut this_ar_number = 0;
let mut changed_action_records = 0;
let mut changed_txn_num = Vec::new();
println!("Creating transactions...");
for result in rdr.records() {
// rdr's cursor is at row 5, which is the first transaction row
let record = result?;
this_tx_number += 1;
// First, initialize metadata fields.
let mut this_tx_date: &str = "";
let mut this_proceeds: &str;
let mut this_memo: &str = "";
let mut proceeds_parsed = 0f32;
// Next, create action_records.
let mut action_records_map_keys_vec: Vec<u32> = Vec::with_capacity(2);
let mut outgoing_ar: Option<ActionRecord> = None;
let mut incoming_ar: Option<ActionRecord> = None;
let mut outgoing_ar_num: Option<u32> = None;
let mut incoming_ar_num: Option<u32> = None;
for (idx, field) in record.iter().enumerate() {
// Set metadata fields on first three fields.
if idx == 0 { this_tx_date = field; }
else if idx == 1 {
let no_comma_string = field.replace(",", "");
proceeds_parsed = no_comma_string.parse::<f32>()?;
}
else if idx == 2 { this_memo = field; }
// Check for empty strings. If not empty, it's a value for an action_record.
else if field != "" {
this_ar_number += 1;
let ind = idx; // starts at 3, which is the fourth field
let acct_idx = ind - 2; // acct_num and acct_key would be idx + 1, so subtract 2 from ind to get 1
let account_key = acct_idx as u16;
let amount_str = field.replace(",", "");
let mut amount = amount_str.parse::<d128>().unwrap();
// When parsing to a d128, it won't error; rather it'll return a NaN. It must now check for NaN,
// and, if found, attempt to sanitize. These checks will convert accounting/comma format to the expected
// format by removing parentheses from negatives and adding a minus sign in the front. It will also
// attempt to remove empty spaces and currency symbols or designations (e.g. $ or USD).
if amount.is_nan() {
let b = sanitize_string_for_d128_parsing_basic(field).parse::<d128>().unwrap();
amount = b;
};
if amount.is_nan() | ;
if amount.is_nan() {
println!("FATAL: Couldn't convert amount to d128 for transaction:\n{:#?}", record);
std::process::exit(1);
}
let amount_rounded = round_d128_1e8(&amount);
if amount != amount_rounded { changed_action_records += 1; changed_txn_num.push(this_tx_number); }
let action_record = ActionRecord {
account_key,
amount: amount_rounded,
tx_key: this_tx_number,
self_ar_key: this_ar_number,
movements: RefCell::new([].to_vec()),
};
if amount > d128!(0.0) {
incoming_ar = Some(action_record);
incoming_ar_num = Some(this_ar_number);
action_records_map_keys_vec.push(incoming_ar_num.unwrap())
} else {
outgoing_ar = Some(action_record);
outgoing_ar_num = Some(this_ar_number);
action_records_map_keys_vec.insert(0, outgoing_ar_num.unwrap())
};
}
}
// Note: the rust Trait implementation of FromStr for f32 is capable of parsing:
// '3.14'
// '-3.14'
// '2.5E10', or equivalently, '2.5e10'
// '2.5E-10'
// '5.'
// '.5', or, equivalently, '0.5'
// 'inf', '-inf', 'NaN'
// Notable observations from the list:
// (a) scientific notation is accepted
// (b) accounting format (numbers in parens representing negative numbers) is not explicitly accepted
// Additionally notable:
// (a) the decimal separator must be a period
// (b) there can be no commas
// (c) there can be no currency info ($120 or 120USD, etc. will fail to parse)
// In summary, it appears to only allow: (i) numeric chars, (ii) a period, and/or (iii) a minus sign
//
// The Decimal::d128 implementation of FromStr calls into a C library, and that lib hasn't
// been reviewed (by | {
let c = sanitize_string_for_d128_parsing_full(field).parse::<d128>().unwrap();
amount = c;
} | conditional_block |
servergroup.go | promlog.AllowedLevel{},
Format: &promlog.AllowedFormat{},
}
if err := logCfg.Level.Set("info"); err != nil {
return nil, err
}
sg.targetManager = discovery.NewManager(ctx, promlog.New(logCfg))
// Background the updating
go sg.targetManager.Run()
go sg.Sync()
return sg, nil
}
// ServerGroupState encapsulates the state of a serverGroup from service discovery
type ServerGroupState struct {
// Targets is the list of target URLs for this discovery round
Targets []string
apiClient promclient.API
ctx context.Context
ctxCancel context.CancelFunc
}
// ServerGroup encapsulates a set of prometheus downstreams to query/aggregate
type ServerGroup struct {
ctx context.Context
ctxCancel context.CancelFunc
loaded bool
Ready chan struct{}
// TODO: lock/atomics on cfg and client
Cfg *Config
client *http.Client
targetManager *discovery.Manager
OriginalURLs []string
state atomic.Value
}
// Cancel stops backround processes (e.g. discovery manager)
func (s *ServerGroup) Cancel() {
s.ctxCancel()
}
// RoundTrip allows us to intercept and mutate downstream HTTP requests at the transport level
func (s *ServerGroup) RoundTrip(r *http.Request) (*http.Response, error) {
for k, v := range middleware.GetHeaders(r.Context()) {
r.Header.Set(k, v)
}
return s.client.Transport.RoundTrip(r)
}
// Sync updates the targets from our discovery manager
func (s *ServerGroup) Sync() {
syncCh := s.targetManager.SyncCh()
for {
select {
case <-s.ctx.Done():
return
case targetGroupMap := <-syncCh:
logrus.Debug("Updating targets from discovery manager")
// TODO: retry and error handling
err := s.loadTargetGroupMap(targetGroupMap)
for err != nil {
logrus.Errorf("Error loading servergroup, retrying: %v", err)
// TODO: configurable backoff
select {
case <-time.After(time.Second):
err = s.loadTargetGroupMap(targetGroupMap)
case <-s.ctx.Done():
return
}
}
}
}
}
func (s *ServerGroup) loadTargetGroupMap(targetGroupMap map[string][]*targetgroup.Group) (err error) {
targets := make([]string, 0)
apiClients := make([]promclient.API, 0)
ctx, ctxCancel := context.WithCancel(context.Background())
defer func() {
if err != nil {
ctxCancel()
}
}()
for _, targetGroupList := range targetGroupMap {
for _, targetGroup := range targetGroupList {
for _, target := range targetGroup.Targets {
lbls := make([]labels.Label, 0, len(target)+len(targetGroup.Labels)+2)
for ln, lv := range target {
lbls = append(lbls, labels.Label{Name: string(ln), Value: string(lv)})
}
for ln, lv := range targetGroup.Labels {
if _, ok := target[ln]; !ok {
lbls = append(lbls, labels.Label{Name: string(ln), Value: string(lv)})
}
}
lbls = append(lbls, labels.Label{Name: model.SchemeLabel, Value: string(s.Cfg.Scheme)})
lbls = append(lbls, labels.Label{Name: PathPrefixLabel, Value: string(s.Cfg.PathPrefix)})
lset := labels.New(lbls...)
logrus.Tracef("Potential target pre-relabel: %v", lset)
lset = relabel.Process(lset, s.Cfg.RelabelConfigs...)
logrus.Tracef("Potential target post-relabel: %v", lset)
// Check if the target was dropped, if so we skip it
if len(lset) == 0 {
continue
}
// If there is no address, then we can't use this set of targets
if v := lset.Get(model.AddressLabel); v == "" {
return fmt.Errorf("discovery target is missing address label: %v", lset)
}
u := &url.URL{
Scheme: lset.Get(model.SchemeLabel),
Host: lset.Get(model.AddressLabel),
Path: lset.Get(PathPrefixLabel),
}
targets = append(targets, u.Host)
client, err := api.NewClient(api.Config{Address: u.String(), RoundTripper: s})
if err != nil {
return err
}
if len(s.Cfg.QueryParams) > 0 {
client = promclient.NewClientArgsWrap(client, s.Cfg.QueryParams)
}
var apiClient promclient.API
apiClient = &promclient.PromAPIV1{v1.NewAPI(client)}
// If debug logging is enabled, wrap the client with a debugAPI client
// Since these are called in the reverse order of what we add, we want
// to make sure that this is the first wrap of the client
if logrus.GetLevel() >= logrus.DebugLevel {
apiClient = &promclient.DebugAPI{apiClient, u.String()}
}
if s.Cfg.RemoteRead {
u.Path = path.Join(u.Path, s.Cfg.RemoteReadPath)
cfg := &remote.ClientConfig{
URL: &config_util.URL{u},
HTTPClientConfig: s.Cfg.HTTPConfig.HTTPConfig,
Timeout: model.Duration(time.Minute * 2),
}
remoteStorageClient, err := remote.NewReadClient("foo", cfg)
if err != nil {
return err
}
apiClient = &promclient.PromAPIRemoteRead{apiClient, remoteStorageClient}
}
// Optionally add time range layers
if s.Cfg.AbsoluteTimeRangeConfig != nil {
apiClient = &promclient.AbsoluteTimeFilter{
API: apiClient,
Start: s.Cfg.AbsoluteTimeRangeConfig.Start,
End: s.Cfg.AbsoluteTimeRangeConfig.End,
Truncate: s.Cfg.AbsoluteTimeRangeConfig.Truncate,
}
}
if s.Cfg.RelativeTimeRangeConfig != nil {
apiClient = &promclient.RelativeTimeFilter{
API: apiClient,
Start: s.Cfg.RelativeTimeRangeConfig.Start,
End: s.Cfg.RelativeTimeRangeConfig.End,
Truncate: s.Cfg.RelativeTimeRangeConfig.Truncate,
}
}
// We remove all private labels after we set the target entry
modelLabelSet := make(model.LabelSet, len(lset))
for _, lbl := range lset {
if !strings.HasPrefix(string(lbl.Name), model.ReservedLabelPrefix) {
modelLabelSet[model.LabelName(lbl.Name)] = model.LabelValue(lbl.Value)
}
}
// Add labels
apiClient = &promclient.AddLabelClient{apiClient, modelLabelSet.Merge(s.Cfg.Labels)}
// Add MetricRelabel if set
if len(s.Cfg.MetricsRelabelConfigs) > 0 {
tmp, err := promclient.NewMetricsRelabelClient(apiClient, s.Cfg.MetricsRelabelConfigs)
if err != nil {
return err
}
apiClient = tmp
}
// Add LabelFilter if configured
if s.Cfg.LabelFilterConfig != nil {
apiClient, err = promclient.NewLabelFilterClient(ctx, apiClient, s.Cfg.LabelFilterConfig)
if err != nil |
}
apiClients = append(apiClients, apiClient)
}
}
}
apiClientMetricFunc := func(i int, api, status string, took float64) {
serverGroupSummary.WithLabelValues(targets[i], api, status).Observe(took)
}
logrus.Debugf("Updating targets from discovery manager: %v", targets)
apiClient, err := promclient.NewMultiAPI(apiClients, s.Cfg.GetAntiAffinity(), apiClientMetricFunc, 1, s.Cfg.GetPreferMax())
if err != nil {
return err
}
newState := &ServerGroupState{
Targets: targets,
apiClient: apiClient,
ctx: ctx,
ctxCancel: ctxCancel,
}
if s.Cfg.IgnoreError {
newState.apiClient = &promclient.IgnoreErrorAPI{newState.apiClient}
}
oldState := s.State() // Fetch the current state (so we can stop it)
s.state.Store(newState) // Store new state
if oldState != nil {
oldState.ctxCancel() // Cancel the old state
}
if !s.loaded {
s.loaded = true
close(s.Ready)
}
return nil
}
// ApplyConfig applies new configuration to the ServerGroup
// TODO: move config + client into state object to be swapped with atomics
func (s *ServerGroup) ApplyConfig(cfg *Config) error {
s.Cfg = cfg
// Copy/paste from upstream prometheus/common until https://github.com/prometheus/common/issues/144 is resolved
tlsConfig, err := config_util.NewTLSConfig(&cfg.HTTPConfig.HTTPConfig.TLSConfig)
if err != nil {
return errors.Wrap(err, "error loading TLS client config")
}
// The | {
return err
} | conditional_block |
servergroup.go | cheme: lset.Get(model.SchemeLabel),
Host: lset.Get(model.AddressLabel),
Path: lset.Get(PathPrefixLabel),
}
targets = append(targets, u.Host)
client, err := api.NewClient(api.Config{Address: u.String(), RoundTripper: s})
if err != nil {
return err
}
if len(s.Cfg.QueryParams) > 0 {
client = promclient.NewClientArgsWrap(client, s.Cfg.QueryParams)
}
var apiClient promclient.API
apiClient = &promclient.PromAPIV1{v1.NewAPI(client)}
// If debug logging is enabled, wrap the client with a debugAPI client
// Since these are called in the reverse order of what we add, we want
// to make sure that this is the first wrap of the client
if logrus.GetLevel() >= logrus.DebugLevel {
apiClient = &promclient.DebugAPI{apiClient, u.String()}
}
if s.Cfg.RemoteRead {
u.Path = path.Join(u.Path, s.Cfg.RemoteReadPath)
cfg := &remote.ClientConfig{
URL: &config_util.URL{u},
HTTPClientConfig: s.Cfg.HTTPConfig.HTTPConfig,
Timeout: model.Duration(time.Minute * 2),
}
remoteStorageClient, err := remote.NewReadClient("foo", cfg)
if err != nil {
return err
}
apiClient = &promclient.PromAPIRemoteRead{apiClient, remoteStorageClient}
}
// Optionally add time range layers
if s.Cfg.AbsoluteTimeRangeConfig != nil {
apiClient = &promclient.AbsoluteTimeFilter{
API: apiClient,
Start: s.Cfg.AbsoluteTimeRangeConfig.Start,
End: s.Cfg.AbsoluteTimeRangeConfig.End,
Truncate: s.Cfg.AbsoluteTimeRangeConfig.Truncate,
}
}
if s.Cfg.RelativeTimeRangeConfig != nil {
apiClient = &promclient.RelativeTimeFilter{
API: apiClient,
Start: s.Cfg.RelativeTimeRangeConfig.Start,
End: s.Cfg.RelativeTimeRangeConfig.End,
Truncate: s.Cfg.RelativeTimeRangeConfig.Truncate,
}
}
// We remove all private labels after we set the target entry
modelLabelSet := make(model.LabelSet, len(lset))
for _, lbl := range lset {
if !strings.HasPrefix(string(lbl.Name), model.ReservedLabelPrefix) {
modelLabelSet[model.LabelName(lbl.Name)] = model.LabelValue(lbl.Value)
}
}
// Add labels
apiClient = &promclient.AddLabelClient{apiClient, modelLabelSet.Merge(s.Cfg.Labels)}
// Add MetricRelabel if set
if len(s.Cfg.MetricsRelabelConfigs) > 0 {
tmp, err := promclient.NewMetricsRelabelClient(apiClient, s.Cfg.MetricsRelabelConfigs)
if err != nil {
return err
}
apiClient = tmp
}
// Add LabelFilter if configured
if s.Cfg.LabelFilterConfig != nil {
apiClient, err = promclient.NewLabelFilterClient(ctx, apiClient, s.Cfg.LabelFilterConfig)
if err != nil {
return err
}
}
apiClients = append(apiClients, apiClient)
}
}
}
apiClientMetricFunc := func(i int, api, status string, took float64) {
serverGroupSummary.WithLabelValues(targets[i], api, status).Observe(took)
}
logrus.Debugf("Updating targets from discovery manager: %v", targets)
apiClient, err := promclient.NewMultiAPI(apiClients, s.Cfg.GetAntiAffinity(), apiClientMetricFunc, 1, s.Cfg.GetPreferMax())
if err != nil {
return err
}
newState := &ServerGroupState{
Targets: targets,
apiClient: apiClient,
ctx: ctx,
ctxCancel: ctxCancel,
}
if s.Cfg.IgnoreError {
newState.apiClient = &promclient.IgnoreErrorAPI{newState.apiClient}
}
oldState := s.State() // Fetch the current state (so we can stop it)
s.state.Store(newState) // Store new state
if oldState != nil {
oldState.ctxCancel() // Cancel the old state
}
if !s.loaded {
s.loaded = true
close(s.Ready)
}
return nil
}
// ApplyConfig applies new configuration to the ServerGroup
// TODO: move config + client into state object to be swapped with atomics
func (s *ServerGroup) ApplyConfig(cfg *Config) error {
s.Cfg = cfg
// Copy/paste from upstream prometheus/common until https://github.com/prometheus/common/issues/144 is resolved
tlsConfig, err := config_util.NewTLSConfig(&cfg.HTTPConfig.HTTPConfig.TLSConfig)
if err != nil {
return errors.Wrap(err, "error loading TLS client config")
}
// The only timeout we care about is the configured scrape timeout.
// It is applied on request. So we leave out any timings here.
var rt http.RoundTripper = &http.Transport{
Proxy: http.ProxyURL(cfg.HTTPConfig.HTTPConfig.ProxyURL.URL),
MaxIdleConns: 20000,
MaxIdleConnsPerHost: 1000, // see https://github.com/golang/go/issues/13801
DisableKeepAlives: false,
TLSClientConfig: tlsConfig,
// 5 minutes is typically above the maximum sane scrape interval. So we can
// use keepalive for all configurations.
IdleConnTimeout: 5 * time.Minute,
DialContext: (&net.Dialer{Timeout: cfg.HTTPConfig.DialTimeout}).DialContext,
ResponseHeaderTimeout: cfg.Timeout,
}
// If a bearer token is provided, create a round tripper that will set the
// Authorization header correctly on each request.
if len(cfg.HTTPConfig.HTTPConfig.BearerToken) > 0 {
rt = config_util.NewAuthorizationCredentialsRoundTripper("Bearer", cfg.HTTPConfig.HTTPConfig.BearerToken, rt)
} else if len(cfg.HTTPConfig.HTTPConfig.BearerTokenFile) > 0 {
rt = config_util.NewAuthorizationCredentialsFileRoundTripper("Bearer", cfg.HTTPConfig.HTTPConfig.BearerTokenFile, rt)
}
if cfg.HTTPConfig.HTTPConfig.BasicAuth != nil {
rt = config_util.NewBasicAuthRoundTripper(cfg.HTTPConfig.HTTPConfig.BasicAuth.Username, cfg.HTTPConfig.HTTPConfig.BasicAuth.Password, cfg.HTTPConfig.HTTPConfig.BasicAuth.PasswordFile, rt)
}
s.client = &http.Client{Transport: rt}
if err := s.targetManager.ApplyConfig(map[string]discovery.Configs{"foo": cfg.ServiceDiscoveryConfigs}); err != nil {
return err
}
return nil
}
// State returns the current ServerGroupState
func (s *ServerGroup) State() *ServerGroupState {
tmp := s.state.Load()
if ret, ok := tmp.(*ServerGroupState); ok {
return ret
}
return nil
}
// GetValue loads the raw data for a given set of matchers in the time range
func (s *ServerGroup) GetValue(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, v1.Warnings, error) {
return s.State().apiClient.GetValue(ctx, start, end, matchers)
}
// Query performs a query for the given time.
func (s *ServerGroup) Query(ctx context.Context, query string, ts time.Time) (model.Value, v1.Warnings, error) {
return s.State().apiClient.Query(ctx, query, ts)
}
// QueryRange performs a query for the given range.
func (s *ServerGroup) QueryRange(ctx context.Context, query string, r v1.Range) (model.Value, v1.Warnings, error) {
return s.State().apiClient.QueryRange(ctx, query, r)
}
// LabelValues performs a query for the values of the given label.
func (s *ServerGroup) LabelValues(ctx context.Context, label string, matchers []string, startTime time.Time, endTime time.Time) (model.LabelValues, v1.Warnings, error) {
return s.State().apiClient.LabelValues(ctx, label, matchers, startTime, endTime)
}
// LabelNames returns all the unique label names present in the block in sorted order.
func (s *ServerGroup) LabelNames(ctx context.Context, matchers []string, startTime time.Time, endTime time.Time) ([]string, v1.Warnings, error) {
return s.State().apiClient.LabelNames(ctx, matchers, startTime, endTime)
}
// Series finds series by label matchers.
func (s *ServerGroup) Series(ctx context.Context, matches []string, startTime, endTime time.Time) ([]model.LabelSet, v1.Warnings, error) {
return s.State().apiClient.Series(ctx, matches, startTime, endTime)
}
// Metadata returns metadata about metrics currently scraped by the metric name.
func (s *ServerGroup) Metadata(ctx context.Context, metric, limit string) (map[string][]v1.Metadata, error) | {
return s.State().apiClient.Metadata(ctx, metric, limit)
} | identifier_body | |
servergroup.go | .PathPrefix)})
lset := labels.New(lbls...)
logrus.Tracef("Potential target pre-relabel: %v", lset)
lset = relabel.Process(lset, s.Cfg.RelabelConfigs...)
logrus.Tracef("Potential target post-relabel: %v", lset)
// Check if the target was dropped, if so we skip it
if len(lset) == 0 {
continue
}
// If there is no address, then we can't use this set of targets
if v := lset.Get(model.AddressLabel); v == "" {
return fmt.Errorf("discovery target is missing address label: %v", lset)
}
u := &url.URL{
Scheme: lset.Get(model.SchemeLabel),
Host: lset.Get(model.AddressLabel),
Path: lset.Get(PathPrefixLabel),
}
targets = append(targets, u.Host)
client, err := api.NewClient(api.Config{Address: u.String(), RoundTripper: s})
if err != nil {
return err
}
if len(s.Cfg.QueryParams) > 0 {
client = promclient.NewClientArgsWrap(client, s.Cfg.QueryParams)
}
var apiClient promclient.API
apiClient = &promclient.PromAPIV1{v1.NewAPI(client)}
// If debug logging is enabled, wrap the client with a debugAPI client
// Since these are called in the reverse order of what we add, we want
// to make sure that this is the first wrap of the client
if logrus.GetLevel() >= logrus.DebugLevel {
apiClient = &promclient.DebugAPI{apiClient, u.String()}
}
if s.Cfg.RemoteRead {
u.Path = path.Join(u.Path, s.Cfg.RemoteReadPath)
cfg := &remote.ClientConfig{
URL: &config_util.URL{u},
HTTPClientConfig: s.Cfg.HTTPConfig.HTTPConfig,
Timeout: model.Duration(time.Minute * 2),
}
remoteStorageClient, err := remote.NewReadClient("foo", cfg)
if err != nil {
return err
}
apiClient = &promclient.PromAPIRemoteRead{apiClient, remoteStorageClient}
}
// Optionally add time range layers
if s.Cfg.AbsoluteTimeRangeConfig != nil {
apiClient = &promclient.AbsoluteTimeFilter{
API: apiClient,
Start: s.Cfg.AbsoluteTimeRangeConfig.Start,
End: s.Cfg.AbsoluteTimeRangeConfig.End,
Truncate: s.Cfg.AbsoluteTimeRangeConfig.Truncate,
}
}
if s.Cfg.RelativeTimeRangeConfig != nil {
apiClient = &promclient.RelativeTimeFilter{
API: apiClient,
Start: s.Cfg.RelativeTimeRangeConfig.Start,
End: s.Cfg.RelativeTimeRangeConfig.End,
Truncate: s.Cfg.RelativeTimeRangeConfig.Truncate,
}
}
// We remove all private labels after we set the target entry
modelLabelSet := make(model.LabelSet, len(lset))
for _, lbl := range lset {
if !strings.HasPrefix(string(lbl.Name), model.ReservedLabelPrefix) {
modelLabelSet[model.LabelName(lbl.Name)] = model.LabelValue(lbl.Value)
}
}
// Add labels
apiClient = &promclient.AddLabelClient{apiClient, modelLabelSet.Merge(s.Cfg.Labels)}
// Add MetricRelabel if set
if len(s.Cfg.MetricsRelabelConfigs) > 0 {
tmp, err := promclient.NewMetricsRelabelClient(apiClient, s.Cfg.MetricsRelabelConfigs)
if err != nil {
return err
}
apiClient = tmp
}
// Add LabelFilter if configured
if s.Cfg.LabelFilterConfig != nil {
apiClient, err = promclient.NewLabelFilterClient(ctx, apiClient, s.Cfg.LabelFilterConfig)
if err != nil {
return err
}
}
apiClients = append(apiClients, apiClient)
}
}
}
apiClientMetricFunc := func(i int, api, status string, took float64) {
serverGroupSummary.WithLabelValues(targets[i], api, status).Observe(took)
}
logrus.Debugf("Updating targets from discovery manager: %v", targets)
apiClient, err := promclient.NewMultiAPI(apiClients, s.Cfg.GetAntiAffinity(), apiClientMetricFunc, 1, s.Cfg.GetPreferMax())
if err != nil {
return err
}
newState := &ServerGroupState{
Targets: targets,
apiClient: apiClient,
ctx: ctx,
ctxCancel: ctxCancel,
}
if s.Cfg.IgnoreError {
newState.apiClient = &promclient.IgnoreErrorAPI{newState.apiClient}
}
oldState := s.State() // Fetch the current state (so we can stop it)
s.state.Store(newState) // Store new state
if oldState != nil {
oldState.ctxCancel() // Cancel the old state
}
if !s.loaded {
s.loaded = true
close(s.Ready)
}
return nil
}
// ApplyConfig applies new configuration to the ServerGroup
// TODO: move config + client into state object to be swapped with atomics
func (s *ServerGroup) ApplyConfig(cfg *Config) error {
s.Cfg = cfg
// Copy/paste from upstream prometheus/common until https://github.com/prometheus/common/issues/144 is resolved
tlsConfig, err := config_util.NewTLSConfig(&cfg.HTTPConfig.HTTPConfig.TLSConfig)
if err != nil {
return errors.Wrap(err, "error loading TLS client config")
}
// The only timeout we care about is the configured scrape timeout.
// It is applied on request. So we leave out any timings here.
var rt http.RoundTripper = &http.Transport{
Proxy: http.ProxyURL(cfg.HTTPConfig.HTTPConfig.ProxyURL.URL),
MaxIdleConns: 20000,
MaxIdleConnsPerHost: 1000, // see https://github.com/golang/go/issues/13801
DisableKeepAlives: false,
TLSClientConfig: tlsConfig,
// 5 minutes is typically above the maximum sane scrape interval. So we can
// use keepalive for all configurations.
IdleConnTimeout: 5 * time.Minute,
DialContext: (&net.Dialer{Timeout: cfg.HTTPConfig.DialTimeout}).DialContext,
ResponseHeaderTimeout: cfg.Timeout,
}
// If a bearer token is provided, create a round tripper that will set the
// Authorization header correctly on each request.
if len(cfg.HTTPConfig.HTTPConfig.BearerToken) > 0 {
rt = config_util.NewAuthorizationCredentialsRoundTripper("Bearer", cfg.HTTPConfig.HTTPConfig.BearerToken, rt)
} else if len(cfg.HTTPConfig.HTTPConfig.BearerTokenFile) > 0 {
rt = config_util.NewAuthorizationCredentialsFileRoundTripper("Bearer", cfg.HTTPConfig.HTTPConfig.BearerTokenFile, rt)
}
if cfg.HTTPConfig.HTTPConfig.BasicAuth != nil {
rt = config_util.NewBasicAuthRoundTripper(cfg.HTTPConfig.HTTPConfig.BasicAuth.Username, cfg.HTTPConfig.HTTPConfig.BasicAuth.Password, cfg.HTTPConfig.HTTPConfig.BasicAuth.PasswordFile, rt)
}
s.client = &http.Client{Transport: rt}
if err := s.targetManager.ApplyConfig(map[string]discovery.Configs{"foo": cfg.ServiceDiscoveryConfigs}); err != nil {
return err
}
return nil
}
// State returns the current ServerGroupState
func (s *ServerGroup) State() *ServerGroupState {
tmp := s.state.Load()
if ret, ok := tmp.(*ServerGroupState); ok {
return ret
}
return nil
}
// GetValue loads the raw data for a given set of matchers in the time range
func (s *ServerGroup) GetValue(ctx context.Context, start, end time.Time, matchers []*labels.Matcher) (model.Value, v1.Warnings, error) {
return s.State().apiClient.GetValue(ctx, start, end, matchers)
}
// Query performs a query for the given time.
func (s *ServerGroup) Query(ctx context.Context, query string, ts time.Time) (model.Value, v1.Warnings, error) {
return s.State().apiClient.Query(ctx, query, ts)
}
// QueryRange performs a query for the given range.
func (s *ServerGroup) QueryRange(ctx context.Context, query string, r v1.Range) (model.Value, v1.Warnings, error) {
return s.State().apiClient.QueryRange(ctx, query, r)
}
// LabelValues performs a query for the values of the given label.
func (s *ServerGroup) LabelValues(ctx context.Context, label string, matchers []string, startTime time.Time, endTime time.Time) (model.LabelValues, v1.Warnings, error) {
return s.State().apiClient.LabelValues(ctx, label, matchers, startTime, endTime)
}
// LabelNames returns all the unique label names present in the block in sorted order.
func (s *ServerGroup) | LabelNames | identifier_name | |
servergroup.go | &promlog.AllowedLevel{},
Format: &promlog.AllowedFormat{},
}
if err := logCfg.Level.Set("info"); err != nil {
return nil, err
}
sg.targetManager = discovery.NewManager(ctx, promlog.New(logCfg))
// Background the updating
go sg.targetManager.Run()
go sg.Sync()
return sg, nil
}
// ServerGroupState encapsulates the state of a serverGroup from service discovery
type ServerGroupState struct {
// Targets is the list of target URLs for this discovery round
Targets []string
apiClient promclient.API
ctx context.Context
ctxCancel context.CancelFunc
}
// ServerGroup encapsulates a set of prometheus downstreams to query/aggregate
type ServerGroup struct {
ctx context.Context
ctxCancel context.CancelFunc
loaded bool
Ready chan struct{}
// TODO: lock/atomics on cfg and client
Cfg *Config
client *http.Client
targetManager *discovery.Manager
OriginalURLs []string
state atomic.Value
}
// Cancel stops backround processes (e.g. discovery manager)
func (s *ServerGroup) Cancel() {
s.ctxCancel()
}
// RoundTrip allows us to intercept and mutate downstream HTTP requests at the transport level
func (s *ServerGroup) RoundTrip(r *http.Request) (*http.Response, error) {
for k, v := range middleware.GetHeaders(r.Context()) {
r.Header.Set(k, v)
}
return s.client.Transport.RoundTrip(r)
}
// Sync updates the targets from our discovery manager
func (s *ServerGroup) Sync() {
syncCh := s.targetManager.SyncCh()
for {
select {
case <-s.ctx.Done():
return
case targetGroupMap := <-syncCh:
logrus.Debug("Updating targets from discovery manager")
// TODO: retry and error handling
err := s.loadTargetGroupMap(targetGroupMap)
for err != nil {
logrus.Errorf("Error loading servergroup, retrying: %v", err)
// TODO: configurable backoff
select {
case <-time.After(time.Second):
err = s.loadTargetGroupMap(targetGroupMap)
case <-s.ctx.Done():
return
}
}
}
}
}
func (s *ServerGroup) loadTargetGroupMap(targetGroupMap map[string][]*targetgroup.Group) (err error) {
targets := make([]string, 0)
apiClients := make([]promclient.API, 0)
ctx, ctxCancel := context.WithCancel(context.Background())
defer func() {
if err != nil {
ctxCancel()
}
}()
for _, targetGroupList := range targetGroupMap {
for _, targetGroup := range targetGroupList {
for _, target := range targetGroup.Targets {
lbls := make([]labels.Label, 0, len(target)+len(targetGroup.Labels)+2)
for ln, lv := range target {
lbls = append(lbls, labels.Label{Name: string(ln), Value: string(lv)})
}
for ln, lv := range targetGroup.Labels {
if _, ok := target[ln]; !ok {
lbls = append(lbls, labels.Label{Name: string(ln), Value: string(lv)})
}
}
lbls = append(lbls, labels.Label{Name: model.SchemeLabel, Value: string(s.Cfg.Scheme)})
lbls = append(lbls, labels.Label{Name: PathPrefixLabel, Value: string(s.Cfg.PathPrefix)})
lset := labels.New(lbls...)
logrus.Tracef("Potential target pre-relabel: %v", lset)
lset = relabel.Process(lset, s.Cfg.RelabelConfigs...)
logrus.Tracef("Potential target post-relabel: %v", lset)
// Check if the target was dropped, if so we skip it
if len(lset) == 0 {
continue
}
// If there is no address, then we can't use this set of targets
if v := lset.Get(model.AddressLabel); v == "" {
return fmt.Errorf("discovery target is missing address label: %v", lset)
}
u := &url.URL{
Scheme: lset.Get(model.SchemeLabel),
Host: lset.Get(model.AddressLabel),
Path: lset.Get(PathPrefixLabel),
}
targets = append(targets, u.Host)
client, err := api.NewClient(api.Config{Address: u.String(), RoundTripper: s})
if err != nil {
return err
}
if len(s.Cfg.QueryParams) > 0 {
client = promclient.NewClientArgsWrap(client, s.Cfg.QueryParams)
}
var apiClient promclient.API
apiClient = &promclient.PromAPIV1{v1.NewAPI(client)}
// If debug logging is enabled, wrap the client with a debugAPI client
// Since these are called in the reverse order of what we add, we want
// to make sure that this is the first wrap of the client
if logrus.GetLevel() >= logrus.DebugLevel {
apiClient = &promclient.DebugAPI{apiClient, u.String()}
}
if s.Cfg.RemoteRead {
u.Path = path.Join(u.Path, s.Cfg.RemoteReadPath)
cfg := &remote.ClientConfig{
URL: &config_util.URL{u},
HTTPClientConfig: s.Cfg.HTTPConfig.HTTPConfig,
Timeout: model.Duration(time.Minute * 2),
}
remoteStorageClient, err := remote.NewReadClient("foo", cfg)
if err != nil {
return err
}
apiClient = &promclient.PromAPIRemoteRead{apiClient, remoteStorageClient}
}
// Optionally add time range layers
if s.Cfg.AbsoluteTimeRangeConfig != nil {
apiClient = &promclient.AbsoluteTimeFilter{ | End: s.Cfg.AbsoluteTimeRangeConfig.End,
Truncate: s.Cfg.AbsoluteTimeRangeConfig.Truncate,
}
}
if s.Cfg.RelativeTimeRangeConfig != nil {
apiClient = &promclient.RelativeTimeFilter{
API: apiClient,
Start: s.Cfg.RelativeTimeRangeConfig.Start,
End: s.Cfg.RelativeTimeRangeConfig.End,
Truncate: s.Cfg.RelativeTimeRangeConfig.Truncate,
}
}
// We remove all private labels after we set the target entry
modelLabelSet := make(model.LabelSet, len(lset))
for _, lbl := range lset {
if !strings.HasPrefix(string(lbl.Name), model.ReservedLabelPrefix) {
modelLabelSet[model.LabelName(lbl.Name)] = model.LabelValue(lbl.Value)
}
}
// Add labels
apiClient = &promclient.AddLabelClient{apiClient, modelLabelSet.Merge(s.Cfg.Labels)}
// Add MetricRelabel if set
if len(s.Cfg.MetricsRelabelConfigs) > 0 {
tmp, err := promclient.NewMetricsRelabelClient(apiClient, s.Cfg.MetricsRelabelConfigs)
if err != nil {
return err
}
apiClient = tmp
}
// Add LabelFilter if configured
if s.Cfg.LabelFilterConfig != nil {
apiClient, err = promclient.NewLabelFilterClient(ctx, apiClient, s.Cfg.LabelFilterConfig)
if err != nil {
return err
}
}
apiClients = append(apiClients, apiClient)
}
}
}
apiClientMetricFunc := func(i int, api, status string, took float64) {
serverGroupSummary.WithLabelValues(targets[i], api, status).Observe(took)
}
logrus.Debugf("Updating targets from discovery manager: %v", targets)
apiClient, err := promclient.NewMultiAPI(apiClients, s.Cfg.GetAntiAffinity(), apiClientMetricFunc, 1, s.Cfg.GetPreferMax())
if err != nil {
return err
}
newState := &ServerGroupState{
Targets: targets,
apiClient: apiClient,
ctx: ctx,
ctxCancel: ctxCancel,
}
if s.Cfg.IgnoreError {
newState.apiClient = &promclient.IgnoreErrorAPI{newState.apiClient}
}
oldState := s.State() // Fetch the current state (so we can stop it)
s.state.Store(newState) // Store new state
if oldState != nil {
oldState.ctxCancel() // Cancel the old state
}
if !s.loaded {
s.loaded = true
close(s.Ready)
}
return nil
}
// ApplyConfig applies new configuration to the ServerGroup
// TODO: move config + client into state object to be swapped with atomics
func (s *ServerGroup) ApplyConfig(cfg *Config) error {
s.Cfg = cfg
// Copy/paste from upstream prometheus/common until https://github.com/prometheus/common/issues/144 is resolved
tlsConfig, err := config_util.NewTLSConfig(&cfg.HTTPConfig.HTTPConfig.TLSConfig)
if err != nil {
return errors.Wrap(err, "error loading TLS client config")
}
// The only | API: apiClient,
Start: s.Cfg.AbsoluteTimeRangeConfig.Start, | random_line_split |
server.js | }, function(ret) {
if (ret.statusCode) {
console.log("user_" + userData.id + "成功注册推送");
}
});
}
};
//推送开关
var _push = {
open: function(cb) {
var ajpush = api.require('ajpush');
if (ajpush) {
ajpush.resumePush(function(ret) {
if (typeof cb === 'function') {
cb(ret && ret.status);
}
});
} else {
console.log('ajpush插件未就绪');
}
},
close: function(cb) {
var ajpush = api.require('ajpush');
if (ajpush) {
ajpush.stopPush(function(ret) {
if (typeof cb === 'function') {
cb(ret && ret.status);
}
});
} else {
console.log('ajpush插件未就绪');
}
}
};
//获取用户信息
var _getUser = function(hold) {
//测试数据
return {
id: "0001",
headImg: seajs.root + '/res/img/avat.jpg',
nickName: '珊珊',
realName: '伐木累',
nowScore: 99,
mobile: '15067589521'
};
var _user = app.storage.val('user');
if (!$.isPlainObject(_user)) {
app.ready(function() {
app.alert('请先登录！', function() {
app.openView(null, 'member', 'login');
}, {
bgclose: false
});
});
return {};
}
return _user;
};
//坐标反查
var _getAddrByLoc = function(lat, lng, config) {
var def = {
callback: null,
silent: false
};
var opt = $.extend(def, config || {});
var map = api.require('bMap');
var getTimeout = setTimeout(function() {
app.loading.hide();
app.toast('检索超时，请重试', 2000);
}, appcfg.set.longtime);
if (!lat || !lng) {
return app.toast('坐标反查参数错误');
}
if (!opt.silent) {
app.loading.show('正在检索地址...');
}
map.getNameFromCoords({
lon: lng,
lat: lat
}, function(ret, err) {
app.loading.hide();
clearTimeout(getTimeout);
if (err) {
var baiduerrmap = ['', '检索词有岐义', '检索地址有岐义', '没有找到检索结果', 'key错误', '网络连接错误', '网络连接超时', '还未完成鉴权，请在鉴权通过后重试'];
return console.log('百度坐标反查:' + baiduerrmap[err.code]);
}
if (ret.status) {
opt.callback(ret);
} else {
app.toast('百度地图API错误', 2000);
}
});
};
//回传用户注册地
var _uploadifyLocation = function() {
var hasLocat;
var userData = _getUser();
var updateUser = function(location) {
app.ajax({
url: appcfg.api.uploadifyLocation,
data: {
"member_id": userData.id,
"province": location.province,
"city": location.city,
"area": location.district
},
success: function(res) {
if (res.status === 'Y') {
} else {
console.log('回传用户地理位置返回异常：' + res.msg);
}
},
error: function(o) {
console.log('回传用户地理位置发生错误');
}
});
};
_getLocation(function(lat, lng) {
_getAddrByLoc(lat, lng, {
silent: true,
callback: function(res) {
var location = {};
location.lng = lng;
location.lat = lat;
location.province = res.province;
location.city = res.city;
location.district = res.district;
location.streetName = res.streetName;
location.streetNumber = res.streetNumber;
updateUser(location);
}
});
});
};
//收集信息
var _collection = function() {
var oldInfo = app.storage.val('DeviceInfo') || {},
newInfo = {},
send = function(extraParam) {
var userData = app.storage.val('user'),
hasChange;
extraParam.saveDate = _getDate(false, true);
//日期过滤
if (oldInfo.saveDate && oldInfo.saveDate >= extraParam.saveDate) {
return null;
}
//信息改变过滤
$.each(extraParam, function(i, e) {
if (e !== oldInfo[i]) {
hasChange = true;
return null;
}
});
if (hasChange && $.isPlainObject(userData)) {
app.storage.val('DeviceInfo', extraParam);
var data = $.extend({
member_id: userData.id
}, extraParam);
app.ajax({
url: appcfg.api.loginLog,
data: data,
success: function(res) {
},
error: function() {
console.log('回传设备信息时发生错误');
}
});
}
};
newInfo.app_version = appcfg.set.version;
newInfo.os = api.systemType;
newInfo.connect_status = api.connectionType;
newInfo.mobile_operator_name = api.operator;
newInfo.model = api.deviceModel;
_getLocation(function(lat, lng) {
newInfo.latitude = lat;
newInfo.longitude = lng;
send(newInfo);
}, function() {
send(newInfo);
});
};
//数据预取
var _preGet = function(cb) {
var got = 0,
preGetList = _preGet.prototype.preGetList,
getOne = function() {
got++;
if (got >= preGetList.length && typeof(cb) === 'function') {
cb();
got = null;
getOne = null;
preGetList = null;
}
};
//开始加载
$.each(preGetList, function(i, e) {
app.ajax({
url: e.url,
data: e.data,
success: function(res) {
getOne();
if (res.status === 'Y') {
var data = res.data;
if (data.split) {
data = JSON.parse(data);
}
app.storage.val(e.key, data);
}
},
error: function() {}
});
});
};
_preGet.prototype.preGetList = [];
//预取配置信息
_preGet.prototype.preGetList.push({
key: 'websiteConfig',
url: appcfg.api.websiteConfig,
data: {}
});
//预取数据
var _checkPreget = function() {
var preGetList = _preGet.prototype.preGetList,
isDone = true;
$.each(preGetList, function(i, e) {
if (!app.storage.val(e.key)) {
_preGet();
isDone = false;
return false;
}
});
return isDone;
};
//检查升级
var _checkUpdate = function(platform, silence) {
var mam = api.require('mam');
mam.checkUpdate(function(ret, err) {
if (ret) {
var result = ret.result;
if (result.update === true && result.closed === false) {
app.confirm(ret.updateTip, function() {
if (platform == 'ios') {
api.installApp({
appUri: result.source
});
} else if (platform == 'android') {
api.download({
url: result.source,
report: true
}, function(ret, err) {
if (ret && 0 === ret.state) { /* 下载进度 */
app.toast("正在下载:" + ret.percent + "%", 1000);
}
if (ret && 1 === ret.state) { /* 下载完成 */
var savePath = ret.savePath;
api.installApp({
appUri: savePath
});
}
});
}
}, null, {
bar: true,
title: '升级到 V' + result.version
});
} else if (!silence) {
app.alert("暂无更新");
}
} else if (!silence) {
app.alert(err.msg);
}
});
};
//获取地理位置
var _getLocation = function(callback, errcb) {
var bMap = api.require('bMap');
var chaoshi = setTimeout(function() {
app.loading.hide();
bMap.stopLocation();
if (app.storage.val('gps')) { | var gpsCache = app.storage.val('gps');
if (typeof(callback) === 'function') {
callback(gpsCache.lat, gpsCache.lng);
}
console.log('定位超时，使用缓存数据'); | random_line_split | |
server.js | {
app.openView(null, 'member', 'login');
}, {
bgclose: false
});
});
return {};
}
return _user;
};
//坐标反查
var _getAddrByLoc = function(lat, lng, config) {
var def = {
callback: null,
silent: false
};
var opt = $.extend(def, config || {});
var map = api.require('bMap');
var getTimeout = setTimeout(function() {
app.loading.hide();
app.toast('检索超时，请重试', 2000);
}, appcfg.set.longtime);
if (!lat || !lng) {
return app.toast('坐标反查参数错误');
}
if (!opt.silent) {
app.loading.show('正在检索地址...');
}
map.getNameFromCoords({
lon: lng,
lat: lat
}, function(ret, err) {
app.loading.hide();
clearTimeout(getTimeout);
if (err) {
var baiduerrmap = ['', '检索词有岐义', '检索地址有岐义', '没有找到检索结果', 'key错误', '网络连接错误', '网络连接超时', '还未完成鉴权，请在鉴权通过后重试'];
return console.log('百度坐标反查:' + baiduerrmap[err.code]);
}
if (ret.status) {
opt.callback(ret);
} else {
app.toast('百度地图API错误', 2000);
}
});
};
//回传用户注册地
var _uploadifyLocation = function() {
var hasLocat;
var userData = _getUser();
var updateUser = function(location) {
app.ajax({
url: appcfg.api.uploadifyLocation,
data: {
"member_id": userData.id,
"province": location.province,
"city": location.city,
"area": location.district
},
success: function(res) {
if (res.status === 'Y') {
} else {
console.log('回传用户地理位置返回异常：' + res.msg);
}
},
error: function(o) {
console.log('回传用户地理位置发生错误');
}
});
};
_getLocation(function(lat, lng) {
_getAddrByLoc(lat, lng, {
silent: true,
callback: function(res) {
var location = {};
location.lng = lng;
location.lat = lat;
location.province = res.province;
location.city = res.city;
location.district = res.district;
location.streetName = res.streetName;
location.streetNumber = res.streetNumber;
updateUser(location);
}
});
});
};
//收集信息
var _collection = function() {
var oldInfo = app.storage.val('DeviceInfo') || {},
newInfo = {},
send = function(extraParam) {
var userData = app.storage.val('user'),
hasChange;
extraParam.saveDate = _getDate(false, true);
//日期过滤
if (oldInfo.saveDate && oldInfo.saveDate >= extraParam.saveDate) {
return null;
}
//信息改变过滤
$.each(extraParam, function(i, e) {
if (e !== oldInfo[i]) {
hasChange = true;
return null;
}
});
if (hasChange && $.isPlainObject(userData)) {
app.storage.val('DeviceInfo', extraParam);
var data = $.extend({
member_id: userData.id
}, extraParam);
app.ajax({
url: appcfg.api.loginLog,
data: data,
success: function(res) {
},
error: function() {
console.log('回传设备信息时发生错误');
}
});
}
};
newInfo.app_version = appcfg.set.version;
newInfo.os = api.systemType;
newInfo.connect_status = api.connectionType;
newInfo.mobile_operator_name = api.operator;
newInfo.model = api.deviceModel;
_getLocation(function(lat, lng) {
newInfo.latitude = lat;
newInfo.longitude = lng;
send(newInfo);
}, function() {
send(newInfo);
});
};
//数据预取
var _preGet = function(cb) {
var got = 0,
preGetList = _preGet.prototype.preGetList,
getOne = function() {
got++;
if (got >= preGetList.length && typeof(cb) === 'function') {
cb();
got = null;
getOne = null;
preGetList = null;
}
};
//开始加载
$.each(preGetList, function(i, e) {
app.ajax({
url: e.url,
data: e.data,
success: function(res) {
getOne();
if (res.status === 'Y') {
var data = res.data;
if (data.split) {
data = JSON.parse(data);
}
app.storage.val(e.key, data);
}
},
error: function() {}
});
});
};
_preGet.prototype.preGetList = [];
//预取配置信息
_preGet.prototype.preGetList.push({
key: 'websiteConfig',
url: appcfg.api.websiteConfig,
data: {}
});
//预取数据
var _checkPreget = function() {
var preGetList = _preGet.prototype.preGetList,
isDone = true;
$.each(preGetList, function(i, e) {
if (!app.storage.val(e.key)) {
_preGet();
isDone = false;
return false;
}
});
return isDone;
};
//检查升级
var _checkUpdate = function(platform, silence) {
var mam = api.require('mam');
mam.checkUpdate(function(ret, err) {
if (ret) {
var result = ret.result;
if (result.update === true && result.closed === false) {
app.confirm(ret.updateTip, function() {
if (platform == 'ios') {
api.installApp({
appUri: result.source
});
} else if (platform == 'android') {
api.download({
url: result.source,
report: true
}, function(ret, err) {
if (ret && 0 === ret.state) { /* 下载进度 */
app.toast("正在下载:" + ret.percent + "%", 1000);
}
if (ret && 1 === ret.state) { /* 下载完成 */
var savePath = ret.savePath;
api.installApp({
appUri: savePath
});
}
});
}
}, null, {
bar: true,
title: '升级到 V' + result.version
});
} else if (!silence) {
app.alert("暂无更新");
}
} else if (!silence) {
app.alert(err.msg);
}
});
};
//获取地理位置
var _getLocation = function(callback, errcb) {
var bMap = api.require('bMap');
var chaoshi = setTimeout(function() {
app.loading.hide();
bMap.stopLocation();
if (app.storage.val('gps')) {
var gpsCache = app.storage.val('gps');
if (typeof(callback) === 'function') {
callback(gpsCache.lat, gpsCache.lng);
}
console.log('定位超时，使用缓存数据');
} else {
if (typeof(errcb) === 'function') {
errcb();
} else {
app.toast('GPS定位超时！', 1000);
}
}
}, appcfg.set.outime);
bMap.getLocation({
accuracy: '10m',
autoStop: true,
filter: 1
}, function(ret, err) {
app.loading.hide();
if (ret && ret.status) {
chaoshi = clearTimeout(chaoshi);
if(ret.lat && ret.lon){
app.storage.val('gps', {
lat: ret.lat,
lng: ret.lon
});
}else{
console.log('bMap.getLocation定位异常');
}
bMap.stopLocation();
if (typeof(callback) === 'function') {
callback(ret.lat, ret.lon);
}
} else {
if (typeof(errcb) === 'function') {
errcb();
} else {
app.toast('GPS定位失败：' + JSON.stringify(err) );
}
}
});
};
//指定DOM打开地图
var _openBaiduMap = function(dom, data, refresh) {
if (!$.isPlainObject(data) || !data.longitude || !data.latitude) {
return app.toast('参数缺失，无法打开地图');
}
var bdMapParam = {
lat: data.latitude,
lng: d | ata.longitude
};
app.storage.val('bdMapData', bdMapParam);
if (refresh) {
ap | conditional_block | |
spline.rs | _sample`]: behaves like [`Spline::sample`] but will return either the first
/// or last key if out of bound; it will return `None` if not enough key.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
pub struct Spline<T, V>(pub(crate) Vec<Key<T, V>>);
impl<T, V> Spline<T, V> {
/// Internal sort to ensure invariant of sorting keys is valid.
fn internal_sort(&mut self) where T: PartialOrd {
self.0.sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less));
}
/// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended
/// to provide ascending sorted ones (for performance purposes).
pub fn from_vec(keys: Vec<Key<T, V>>) -> Self where T: PartialOrd {
let mut spline = Spline(keys);
spline.internal_sort();
spline
}
/// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
/// sorted.
///
/// # Note on iterators
///
/// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should
/// use [`Spline::from_vec`] if you are passing a [`Vec`].
pub fn from_iter<I>(iter: I) -> Self where I: Iterator<Item = Key<T, V>>, T: PartialOrd {
Self::from_vec(iter.collect())
}
/// Retrieve the keys of a spline.
pub fn keys(&self) -> &[Key<T, V>] {
&self.0
}
/// Number of keys.
#[inline(always)]
pub fn len(&self) -> usize {
self.0.len()
}
/// Check whether the spline has no key.
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
/// Sample a spline at a given time, returning the interpolated value along with its associated
/// key.
///
/// The current implementation, based on immutability, cannot perform in constant time. This means
/// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
/// performance by using a slightly different spline type. If you are interested by this feature,
/// an implementation for a dedicated type is foreseen yet not started yet.
///
/// # Return
///
/// `None` if you try to sample a value at a time that has no key associated with. That can also
/// happen if you try to sample between two keys with a specific interpolation mode that makes the
/// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
/// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
/// the sampling.
pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
let keys = &self.0;
let i = search_lower_cp(keys, t)?;
let cp0 = &keys[i];
match cp0.interpolation {
Interpolation::Step(threshold) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = if nt < threshold { cp0.value } else { cp1.value };
Some((value, cp0, Some(cp1)))
}
Interpolation::Linear => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::lerp(cp0.value, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::Cosine => {
let two_t = T::one() + T::one();
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::CatmullRom => {
// We need at least four points for Catmull Rom; ensure we have them, otherwise, return
// None.
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt);
Some((value, cp0, Some(cp1)))
}
}
Interpolation::Bezier(u) => {
// We need to check the next control point to see whether we want quadratic or cubic Bezier.
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value =
if let Interpolation::Bezier(v) = cp1.interpolation {
Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
} else {
Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
};
Some((value, cp0, Some(cp1)))
}
Interpolation::StrokeBezier(input, output) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_bezier(cp0.value, input, output, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::__NonExhaustive => unreachable!(),
}
}
/// Sample a spline at a given time.
///
pub fn sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.sample_with_key(t).map(|(v, _, _)| v)
}
/// Sample a spline at a given time with clamping, returning the interpolated value along with its
/// associated key.
///
/// # Return
///
/// If you sample before the first key or after the last one, return the first key or the last
/// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
///
/// # Error
///
/// This function returns [`None`] if you have no key.
pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
if self.0.is_empty() {
return None;
}
self.sample_with_key(t).or_else(move || {
let first = self.0.first().unwrap();
if t <= first.t {
let second = if self.0.len() >= 2 { Some(&self.0[1]) } else { None };
Some((first.value, &first, second))
} else {
let last = self.0.last().unwrap();
if t >= last.t {
Some((last.value, &last, None))
} else {
None
}
}
})
}
/// Sample a spline at a given time with clamping.
pub fn clamped_sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.clamped_sample_with_key(t).map(|(v, _, _)| v)
}
/// Add a key into the spline.
pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
self.0.push(key);
self.internal_sort();
}
/// Remove a key from the spline.
pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
if index > | key and return the key already present.
///
/// The key is updated — if present — with the provided function.
///
/// # Notes
///
/// That function makes sense only if you | = self.0.len() {
None
} else {
Some(self.0.remove(index))
}
}
/// Update a | identifier_body |
spline.rs | <T, V>>, T: PartialOrd {
Self::from_vec(iter.collect())
}
/// Retrieve the keys of a spline.
pub fn keys(&self) -> &[Key<T, V>] {
&self.0
}
/// Number of keys.
#[inline(always)]
pub fn len(&self) -> usize {
self.0.len()
}
/// Check whether the spline has no key.
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
/// Sample a spline at a given time, returning the interpolated value along with its associated
/// key.
///
/// The current implementation, based on immutability, cannot perform in constant time. This means
/// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
/// performance by using a slightly different spline type. If you are interested by this feature,
/// an implementation for a dedicated type is foreseen yet not started yet.
///
/// # Return
///
/// `None` if you try to sample a value at a time that has no key associated with. That can also
/// happen if you try to sample between two keys with a specific interpolation mode that makes the
/// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
/// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
/// the sampling.
pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
let keys = &self.0;
let i = search_lower_cp(keys, t)?;
let cp0 = &keys[i];
match cp0.interpolation {
Interpolation::Step(threshold) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = if nt < threshold { cp0.value } else { cp1.value };
Some((value, cp0, Some(cp1)))
}
Interpolation::Linear => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::lerp(cp0.value, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::Cosine => {
let two_t = T::one() + T::one();
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::CatmullRom => {
// We need at least four points for Catmull Rom; ensure we have them, otherwise, return
// None.
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt);
Some((value, cp0, Some(cp1)))
}
}
Interpolation::Bezier(u) => {
// We need to check the next control point to see whether we want quadratic or cubic Bezier.
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value =
if let Interpolation::Bezier(v) = cp1.interpolation {
Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
} else {
Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
};
Some((value, cp0, Some(cp1)))
}
Interpolation::StrokeBezier(input, output) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_bezier(cp0.value, input, output, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::__NonExhaustive => unreachable!(),
}
}
/// Sample a spline at a given time.
///
pub fn sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.sample_with_key(t).map(|(v, _, _)| v)
}
/// Sample a spline at a given time with clamping, returning the interpolated value along with its
/// associated key.
///
/// # Return
///
/// If you sample before the first key or after the last one, return the first key or the last
/// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
///
/// # Error
///
/// This function returns [`None`] if you have no key.
pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
if self.0.is_empty() {
return None;
}
self.sample_with_key(t).or_else(move || {
let first = self.0.first().unwrap();
if t <= first.t {
let second = if self.0.len() >= 2 { Some(&self.0[1]) } else { None };
Some((first.value, &first, second))
} else {
let last = self.0.last().unwrap();
if t >= last.t {
Some((last.value, &last, None))
} else {
None
}
}
})
}
/// Sample a spline at a given time with clamping.
pub fn clamped_sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.clamped_sample_with_key(t).map(|(v, _, _)| v)
}
/// Add a key into the spline.
pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
self.0.push(key);
self.internal_sort();
}
/// Remove a key from the spline.
pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
if index >= self.0.len() {
None
} else {
Some(self.0.remove(index))
}
}
/// Update a key and return the key already present.
///
/// The key is updated — if present — with the provided function.
///
/// # Notes
///
/// That function makes sense only if you want to change the interpolator (i.e. [`Key::t`]) of
/// your key. If you just want to change the interpolation mode or the carried value, consider
/// using the [`Spline::get_mut`] method instead as it will be way faster.
pub fn replace<F>(
&mut self,
index: usize,
f: F
) -> Option<Key<T, V>>
where
F: FnOnce(&Key<T, V>) -> Key<T, V>,
T: PartialOrd
{
let key = self.remove(index)?;
self.add(f(&key));
Some(key)
}
/// Get a key at a given index.
pub fn get(&self, index: usize) -> Option<&Key<T, V>> {
self.0.get(index)
}
/// Mutably get a key at a given index.
pub fn get_mut(&mut self, index: usize) -> Option<KeyMut<T, V>> {
self.0.get_mut(index).map(|key| KeyMut {
value: &mut key.value,
interpolation: &mut key.interpolation
})
}
}
/// A mutable [`Key`].
///
/// Mutable keys allow to edit the carried values and the interpolation mode but not the actual
/// interpolator value as it would invalidate the internal structure of the [`Spline`]. If you
/// want to achieve this, you’re advised to use [`Spline::replace`].
pub struct KeyMut<'a, T, V> {
/ | // Car | identifier_name | |
spline.rs | amped_sample`]: behaves like [`Spline::sample`] but will return either the first
/// or last key if out of bound; it will return `None` if not enough key.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
pub struct Spline<T, V>(pub(crate) Vec<Key<T, V>>);
impl<T, V> Spline<T, V> {
/// Internal sort to ensure invariant of sorting keys is valid.
fn internal_sort(&mut self) where T: PartialOrd {
self.0.sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less));
}
/// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended
/// to provide ascending sorted ones (for performance purposes).
pub fn from_vec(keys: Vec<Key<T, V>>) -> Self where T: PartialOrd {
let mut spline = Spline(keys);
spline.internal_sort();
spline
}
/// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
/// sorted.
///
/// # Note on iterators
///
/// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should
/// use [`Spline::from_vec`] if you are passing a [`Vec`].
pub fn from_iter<I>(iter: I) -> Self where I: Iterator<Item = Key<T, V>>, T: PartialOrd {
Self::from_vec(iter.collect())
}
/// Retrieve the keys of a spline.
pub fn keys(&self) -> &[Key<T, V>] {
&self.0
}
/// Number of keys.
#[inline(always)]
pub fn len(&self) -> usize {
self.0.len()
}
/// Check whether the spline has no key.
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
/// Sample a spline at a given time, returning the interpolated value along with its associated
/// key.
///
/// The current implementation, based on immutability, cannot perform in constant time. This means
/// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
/// performance by using a slightly different spline type. If you are interested by this feature,
/// an implementation for a dedicated type is foreseen yet not started yet.
///
/// # Return
///
/// `None` if you try to sample a value at a time that has no key associated with. That can also
/// happen if you try to sample between two keys with a specific interpolation mode that makes the
/// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
/// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
/// the sampling.
pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
let keys = &self.0;
let i = search_lower_cp(keys, t)?;
let cp0 = &keys[i];
match cp0.interpolation {
Interpolation::Step(threshold) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = if nt < threshold { cp0.value } else { cp1.value };
Some((value, cp0, Some(cp1)))
} | Interpolation::Linear => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::lerp(cp0.value, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::Cosine => {
let two_t = T::one() + T::one();
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::CatmullRom => {
// We need at least four points for Catmull Rom; ensure we have them, otherwise, return
// None.
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt);
Some((value, cp0, Some(cp1)))
}
}
Interpolation::Bezier(u) => {
// We need to check the next control point to see whether we want quadratic or cubic Bezier.
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value =
if let Interpolation::Bezier(v) = cp1.interpolation {
Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
} else {
Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
};
Some((value, cp0, Some(cp1)))
}
Interpolation::StrokeBezier(input, output) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_bezier(cp0.value, input, output, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::__NonExhaustive => unreachable!(),
}
}
/// Sample a spline at a given time.
///
pub fn sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.sample_with_key(t).map(|(v, _, _)| v)
}
/// Sample a spline at a given time with clamping, returning the interpolated value along with its
/// associated key.
///
/// # Return
///
/// If you sample before the first key or after the last one, return the first key or the last
/// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
///
/// # Error
///
/// This function returns [`None`] if you have no key.
pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
if self.0.is_empty() {
return None;
}
self.sample_with_key(t).or_else(move || {
let first = self.0.first().unwrap();
if t <= first.t {
let second = if self.0.len() >= 2 { Some(&self.0[1]) } else { None };
Some((first.value, &first, second))
} else {
let last = self.0.last().unwrap();
if t >= last.t {
Some((last.value, &last, None))
} else {
None
}
}
})
}
/// Sample a spline at a given time with clamping.
pub fn clamped_sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.clamped_sample_with_key(t).map(|(v, _, _)| v)
}
/// Add a key into the spline.
pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
self.0.push(key);
self.internal_sort();
}
/// Remove a key from the spline.
pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
if index >= self.0.len() {
None
} else {
Some(self.0.remove(index))
}
}
/// Update a key and return the key already present.
///
/// The key is updated — if present — with the provided function.
///
/// # Notes
///
/// That function makes sense only if you | random_line_split | |
spline.rs | _sample`]: behaves like [`Spline::sample`] but will return either the first
/// or last key if out of bound; it will return `None` if not enough key.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serialization", derive(Deserialize, Serialize))]
pub struct Spline<T, V>(pub(crate) Vec<Key<T, V>>);
impl<T, V> Spline<T, V> {
/// Internal sort to ensure invariant of sorting keys is valid.
fn internal_sort(&mut self) where T: PartialOrd {
self.0.sort_by(|k0, k1| k0.t.partial_cmp(&k1.t).unwrap_or(Ordering::Less));
}
/// Create a new spline out of keys. The keys don’t have to be sorted even though it’s recommended
/// to provide ascending sorted ones (for performance purposes).
pub fn from_vec(keys: Vec<Key<T, V>>) -> Self where T: PartialOrd {
let mut spline = Spline(keys);
spline.internal_sort();
spline
}
/// Create a new spline by consuming an `Iterater<Item = Key<T>>`. They keys don’t have to be
/// sorted.
///
/// # Note on iterators
///
/// It’s valid to use any iterator that implements `Iterator<Item = Key<T>>`. However, you should
/// use [`Spline::from_vec`] if you are passing a [`Vec`].
pub fn from_iter<I>(iter: I) -> Self where I: Iterator<Item = Key<T, V>>, T: PartialOrd {
Self::from_vec(iter.collect())
}
/// Retrieve the keys of a spline.
pub fn keys(&self) -> &[Key<T, V>] {
&self.0
}
/// Number of keys.
#[inline(always)]
pub fn len(&self) -> usize {
self.0.len()
}
/// Check whether the spline has no key.
#[inline(always)]
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
/// Sample a spline at a given time, returning the interpolated value along with its associated
/// key.
///
/// The current implementation, based on immutability, cannot perform in constant time. This means
/// that sampling’s processing complexity is currently *O(log n)*. It’s possible to achieve *O(1)*
/// performance by using a slightly different spline type. If you are interested by this feature,
/// an implementation for a dedicated type is foreseen yet not started yet.
///
/// # Return
///
/// `None` if you try to sample a value at a time that has no key associated with. That can also
/// happen if you try to sample between two keys with a specific interpolation mode that makes the
/// sampling impossible. For instance, [`Interpolation::CatmullRom`] requires *four* keys. If
/// you’re near the beginning of the spline or its end, ensure you have enough keys around to make
/// the sampling.
pub fn sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
let keys = &self.0;
let i = search_lower_cp(keys, t)?;
let cp0 = &keys[i];
match cp0.interpolation {
Interpolation::Step(threshold) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = if nt < threshold { cp0.value } else { cp1.value };
Some((value, cp0, Some(cp1)))
}
Interpolation::Linear => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::lerp(cp0.value, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::Cosine => {
let two_t = T::one() + T::one();
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let cos_nt = (T::one() - (nt * T::pi()).cos()) / two_t;
let value = Interpolate::lerp(cp0.value, cp1.value, cos_nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::CatmullRom => {
// We need at least four points for Catmull Rom; ensure we have them, otherwise, return
// None.
if i == 0 || i >= keys.len() - 2 {
None
} else {
let cp1 = &keys[i + 1];
let cpm0 = &keys[i - 1];
let cpm1 = &keys[i + 2];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_hermite((cpm0.value, cpm0.t), (cp0.value, cp0.t), (cp1.value, cp1.t), (cpm1.value, cpm1.t), nt);
Some((value, cp0, Some(cp1)))
}
}
Interpolation::Bezier(u) => {
// We need to check the next control point to see whether we want quadratic or cubic Bezier.
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value =
if let Interpolation::Bezier(v) = cp1.interpolation {
Interpolate::cubic_bezier(cp0.value, u, v, cp1.value, nt)
} else {
Interpolate::quadratic_bezier(cp0.value, u, cp1.value, nt)
};
Some((value, cp0, Some(cp1)))
}
Interpolation::StrokeBezier(input, output) => {
let cp1 = &keys[i + 1];
let nt = normalize_time(t, cp0, cp1);
let value = Interpolate::cubic_bezier(cp0.value, input, output, cp1.value, nt);
Some((value, cp0, Some(cp1)))
}
Interpolation::__NonExhaustive => unreachable!(),
}
}
/// Sample a spline at a given time.
///
pub fn sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.sample_with_key(t).map(|(v, _, _)| v)
}
/// Sample a spline at a given time with clamping, returning the interpolated value along with its
/// associated key.
///
/// # Return
///
/// If you sample before the first key or after the last one, return the first key or the last
/// one, respectively. Otherwise, behave the same way as [`Spline::sample`].
///
/// # Error
///
/// This function returns [`None`] if you have no key.
pub fn clamped_sample_with_key(&self, t: T) -> Option<(V, &Key<T, V>, Option<&Key<T, V>>)>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
if self.0.is_empty() {
return None;
}
self.sample_with_key(t).or_else(move || {
let first = self.0.first().unwrap();
if t <= first.t {
let second = if self.0.len() >= 2 { Some(&self.0[1]) } else { None };
Some((first.value, &first, second))
} else {
let last = self.0.last().unwrap();
if t >= last.t {
Some | None
}
}
})
}
/// Sample a spline at a given time with clamping.
pub fn clamped_sample(&self, t: T) -> Option<V>
where T: Additive + One + Trigo + Mul<T, Output = T> + Div<T, Output = T> + PartialOrd,
V: Interpolate<T> {
self.clamped_sample_with_key(t).map(|(v, _, _)| v)
}
/// Add a key into the spline.
pub fn add(&mut self, key: Key<T, V>) where T: PartialOrd {
self.0.push(key);
self.internal_sort();
}
/// Remove a key from the spline.
pub fn remove(&mut self, index: usize) -> Option<Key<T, V>> {
if index >= self.0.len() {
None
} else {
Some(self.0.remove(index))
}
}
/// Update a key and return the key already present.
///
/// The key is updated — if present — with the provided function.
///
/// # Notes
///
/// That function makes sense only if you | ((last.value, &last, None))
} else {
| conditional_block |
data_import.py | _splits={only_non_splits}) ...")
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
for row in reader:
splits = canonicalize_and_sort_splits(row.get('splits'))
totle_splits = canonicalize_and_sort_splits(row.get('totle_splits'))
if only_splits and len(splits) < 2: continue
if only_totle_splits and len(totle_splits) < 2: continue
if only_non_splits and len(splits) > 1: continue
if only_totle_non_splits and len(totle_splits) > 1: continue
id, time, action = row['id'], row['time'], row['action'] # datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size, token = float(row['trade_size']), row['token']
exchange, exchange_price = row['exchange'], float(row['exchange_price'])
totle_used, totle_price, pct_savings = row['totle_used'], float(row['totle_price']), float(row['pct_savings']),
# Some older CSVs have the non-splittable dexs in the ex_prices column
ex_prices = exchange_utils.canonical_and_splittable(eval(row.get('ex_prices') or '{}'))
if pct_savings < -1.0:
print(f"{pct_savings} vs {exchange} buying {token} for {trade_size} ETH using {totle_used} {totle_splits} id={id}")
yield time, action, trade_size, token, exchange, exchange_price, totle_used, totle_price, pct_savings, splits, ex_prices
@functools.lru_cache()
def parse_csv_files(csv_files, **kwargs):
"""Returns 2 dicts containing pct savings and prices/split data both having the form
token: { trade_size: {exchange: [sample, sample, ...], ...}
kwargs have these defaults: only_splits=False, only_non_splits=False
"""
per_token_savings = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
slip_price_diff_splits = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
per_file_base_prices = {}
for _, _, trade_size, token, exchange, exchange_price, _, totle_price, pct_savings, splits, _ in csv_row_gen(file, **kwargs):
if not per_file_base_prices.get(token): # this assumes prices recorded from lowest to highest for a token
per_file_base_prices[token] = totle_price # should be same for all aggs, but is slightly different sometimes
slip = (totle_price / per_file_base_prices[token]) - 1.0 # should be 0 for the lowest trade_size
# i.e. slip = (totle_price - per_file_base_prices[token]) / per_file_base_prices[token]
slip = 0.0 if slip < 0.0 and slip > -0.00001 else slip # get rid of -0.0000
price_diff = (totle_price - exchange_price) / exchange_price
slip_price_diff_splits[token][trade_size][exchange].append((slip, price_diff, splits))
per_token_savings[token][trade_size][exchange].append(pct_savings)
return per_token_savings, slip_price_diff_splits
@functools.lru_cache()
def read_slippage_csvs(csv_files=None):
"""Returns a dict of price_slip_cost data points, i.e. {token: {trade_size: {exchange: [ (psc), (psc) ] }}}"""
csv_files = csv_files or glob.glob(f'{CSV_DATA_DIR}/*buy_slippage.csv')
tok_ts_ex_pscs = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
print(f"reading {file} ...")
f_exchange, f_token, *_ = os.path.basename(file).split('_')
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
# time,action,trade_size,token,exchange,exchange_price,slippage,cost
for row in reader:
# time = datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size = float(row['trade_size'])
tok_ts_ex_pscs[f_token][trade_size][f_exchange].append( (float(row['exchange_price']), float(row['slippage']), float(row['cost'])) )
return tok_ts_ex_pscs # TODO: don't return defaultdicts, users should get key errors
# generator
def pct_savings_gen(per_pair_savings):
"""Generates a sequence of (pair, trade_size, agg/exchange, [pct_savings]) for all leaves in the given dict"""
for pair, ts_ex_savings in sorted(per_pair_savings.items()):
for trade_size, ex_savings in ts_ex_savings.items():
for exchange, pct_savings in ex_savings.items():
yield pair, trade_size, exchange, pct_savings
########################################################################################################################
# JSON file aggregation functions
DEX_AG = dexag_client.name()
ONE_INCH = oneinch_client.name()
PARASWAP = paraswap_client.name()
TOTLE_EX = totle_client.name()
AGG_NAMES = [DEX_AG, ONE_INCH, PARASWAP]
JSON_DATA_DIR = f"{os.path.dirname(os.path.abspath(__file__))}/order_splitting_data"
@functools.lru_cache()
def get_all_splits_by_agg(files=None):
"""Returns an aggregated dict of split data, i.e. token: {trade_size: {agg: [{dex: pct, dex: pct}, {...}, ...]}}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_splits_by_agg.json')
tok_ts_splits_by_agg = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_splits_by_agg in json.load(open(f)).items():
for ts, agg_splits in ts_splits_by_agg.items():
for agg, split in agg_splits.items():
tok_ts_splits_by_agg[token][ts][agg].append(split)
return dict(sorted(tok_ts_splits_by_agg.items()))
@functools.lru_cache()
def get_all_dexs_with_pair(files=None):
"""Returns an aggregated dict of DEXs used in splits, i.e. token: {trade_size: [dex, dex, ...]}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dexs_with_pair.json')
tok_ts_dexs_with_pair = defaultdict(lambda: defaultdict(list))
for f in files:
for token, ts_dexs_with_pair in json.load(open(f)).items():
for ts, dexs in ts_dexs_with_pair.items():
tok_ts_dexs_with_pair[token][ts] = list(set(tok_ts_dexs_with_pair[token][ts] + dexs))
return dict(sorted(tok_ts_dexs_with_pair.items()))
@functools.lru_cache()
def get_all_agg_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_agg_prices.json')
tok_ts_agg_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
for agg, price in agg_prices.items():
tok_ts_agg_prices[token][ts][agg].append(price)
return dict(sorted(tok_ts_agg_prices.items()))
@functools.lru_cache()
def get_all_dex_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dex_prices.json')
tok_ts_dex_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
| # "0.5": { ... }
# insert Totle as the agg_name in the aggregated data structure
tok_ts_dex_prices[token][ | for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
# test for agg_name keys because Totle's JSON structure is different from aggs
if any(map(lambda k: k in AGG_NAMES, agg_prices.keys())):
# agg dex_prices files look like this:
# "0.1": {
# "DEX.AG": {
# "Uniswap": 0.003936408446252657,
# "Bancor": 0.003993840558066265
# },
# "Paraswap": { ... }
for agg, prices in agg_prices.items():
tok_ts_dex_prices[token][ts][agg].append(prices)
else:
# Totle's dex_prices file looks like this:
# "0.1": {
# "Ether Delta": 0.00735650292064385,
# "Bancor": 0.003993865645004445,
# "Uniswap": 0.003936433172436365
# }, | conditional_block |
data_import.py | ={only_non_splits}) ...")
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
for row in reader:
splits = canonicalize_and_sort_splits(row.get('splits'))
totle_splits = canonicalize_and_sort_splits(row.get('totle_splits'))
if only_splits and len(splits) < 2: continue
if only_totle_splits and len(totle_splits) < 2: continue
if only_non_splits and len(splits) > 1: continue
if only_totle_non_splits and len(totle_splits) > 1: continue
id, time, action = row['id'], row['time'], row['action'] # datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size, token = float(row['trade_size']), row['token']
exchange, exchange_price = row['exchange'], float(row['exchange_price'])
totle_used, totle_price, pct_savings = row['totle_used'], float(row['totle_price']), float(row['pct_savings']),
# Some older CSVs have the non-splittable dexs in the ex_prices column
ex_prices = exchange_utils.canonical_and_splittable(eval(row.get('ex_prices') or '{}'))
if pct_savings < -1.0:
print(f"{pct_savings} vs {exchange} buying {token} for {trade_size} ETH using {totle_used} {totle_splits} id={id}")
yield time, action, trade_size, token, exchange, exchange_price, totle_used, totle_price, pct_savings, splits, ex_prices
@functools.lru_cache()
def parse_csv_files(csv_files, **kwargs):
"""Returns 2 dicts containing pct savings and prices/split data both having the form
token: { trade_size: {exchange: [sample, sample, ...], ...}
kwargs have these defaults: only_splits=False, only_non_splits=False
"""
per_token_savings = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
slip_price_diff_splits = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
per_file_base_prices = {}
for _, _, trade_size, token, exchange, exchange_price, _, totle_price, pct_savings, splits, _ in csv_row_gen(file, **kwargs):
if not per_file_base_prices.get(token): # this assumes prices recorded from lowest to highest for a token
per_file_base_prices[token] = totle_price # should be same for all aggs, but is slightly different sometimes
slip = (totle_price / per_file_base_prices[token]) - 1.0 # should be 0 for the lowest trade_size
# i.e. slip = (totle_price - per_file_base_prices[token]) / per_file_base_prices[token]
slip = 0.0 if slip < 0.0 and slip > -0.00001 else slip # get rid of -0.0000
price_diff = (totle_price - exchange_price) / exchange_price
slip_price_diff_splits[token][trade_size][exchange].append((slip, price_diff, splits))
per_token_savings[token][trade_size][exchange].append(pct_savings)
return per_token_savings, slip_price_diff_splits
@functools.lru_cache()
def read_slippage_csvs(csv_files=None):
"""Returns a dict of price_slip_cost data points, i.e. {token: {trade_size: {exchange: [ (psc), (psc) ] }}}"""
csv_files = csv_files or glob.glob(f'{CSV_DATA_DIR}/*buy_slippage.csv')
tok_ts_ex_pscs = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
print(f"reading {file} ...")
f_exchange, f_token, *_ = os.path.basename(file).split('_')
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
# time,action,trade_size,token,exchange,exchange_price,slippage,cost
for row in reader:
# time = datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size = float(row['trade_size'])
tok_ts_ex_pscs[f_token][trade_size][f_exchange].append( (float(row['exchange_price']), float(row['slippage']), float(row['cost'])) )
return tok_ts_ex_pscs # TODO: don't return defaultdicts, users should get key errors
# generator
def pct_savings_gen(per_pair_savings):
"""Generates a sequence of (pair, trade_size, agg/exchange, [pct_savings]) for all leaves in the given dict"""
for pair, ts_ex_savings in sorted(per_pair_savings.items()):
for trade_size, ex_savings in ts_ex_savings.items():
for exchange, pct_savings in ex_savings.items():
yield pair, trade_size, exchange, pct_savings
########################################################################################################################
# JSON file aggregation functions
DEX_AG = dexag_client.name()
ONE_INCH = oneinch_client.name()
PARASWAP = paraswap_client.name()
TOTLE_EX = totle_client.name()
AGG_NAMES = [DEX_AG, ONE_INCH, PARASWAP]
JSON_DATA_DIR = f"{os.path.dirname(os.path.abspath(__file__))}/order_splitting_data"
@functools.lru_cache()
def get_all_splits_by_agg(files=None):
"""Returns an aggregated dict of split data, i.e. token: {trade_size: {agg: [{dex: pct, dex: pct}, {...}, ...]}}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_splits_by_agg.json')
tok_ts_splits_by_agg = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_splits_by_agg in json.load(open(f)).items():
for ts, agg_splits in ts_splits_by_agg.items():
for agg, split in agg_splits.items():
tok_ts_splits_by_agg[token][ts][agg].append(split)
return dict(sorted(tok_ts_splits_by_agg.items()))
@functools.lru_cache()
def get_all_dexs_with_pair(files=None):
|
@functools.lru_cache()
def get_all_agg_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_agg_prices.json')
tok_ts_agg_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
for agg, price in agg_prices.items():
tok_ts_agg_prices[token][ts][agg].append(price)
return dict(sorted(tok_ts_agg_prices.items()))
@functools.lru_cache()
def get_all_dex_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dex_prices.json')
tok_ts_dex_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
# test for agg_name keys because Totle's JSON structure is different from aggs
if any(map(lambda k: k in AGG_NAMES, agg_prices.keys())):
# agg dex_prices files look like this:
# "0.1": {
# "DEX.AG": {
# "Uniswap": 0.003936408446252657,
# "Bancor": 0.003993840558066265
# },
# "Paraswap": { ... }
for agg, prices in agg_prices.items():
tok_ts_dex_prices[token][ts][agg].append(prices)
else:
# Totle's dex_prices file looks like this:
# "0.1": {
# "Ether Delta": 0.00735650292064385,
# "Bancor": 0.003993865645004445,
# "Uniswap": 0.003936433172436365
# },
# "0.5": { ... }
# insert Totle as the agg_name in the aggregated data structure
tok_ts_dex_prices[token][ | """Returns an aggregated dict of DEXs used in splits, i.e. token: {trade_size: [dex, dex, ...]}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dexs_with_pair.json')
tok_ts_dexs_with_pair = defaultdict(lambda: defaultdict(list))
for f in files:
for token, ts_dexs_with_pair in json.load(open(f)).items():
for ts, dexs in ts_dexs_with_pair.items():
tok_ts_dexs_with_pair[token][ts] = list(set(tok_ts_dexs_with_pair[token][ts] + dexs))
return dict(sorted(tok_ts_dexs_with_pair.items())) | identifier_body |
data_import.py | _splits={only_non_splits}) ...")
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
for row in reader:
splits = canonicalize_and_sort_splits(row.get('splits'))
totle_splits = canonicalize_and_sort_splits(row.get('totle_splits'))
if only_splits and len(splits) < 2: continue
if only_totle_splits and len(totle_splits) < 2: continue
if only_non_splits and len(splits) > 1: continue
if only_totle_non_splits and len(totle_splits) > 1: continue
id, time, action = row['id'], row['time'], row['action'] # datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size, token = float(row['trade_size']), row['token']
exchange, exchange_price = row['exchange'], float(row['exchange_price'])
totle_used, totle_price, pct_savings = row['totle_used'], float(row['totle_price']), float(row['pct_savings']),
# Some older CSVs have the non-splittable dexs in the ex_prices column
ex_prices = exchange_utils.canonical_and_splittable(eval(row.get('ex_prices') or '{}'))
if pct_savings < -1.0:
print(f"{pct_savings} vs {exchange} buying {token} for {trade_size} ETH using {totle_used} {totle_splits} id={id}")
yield time, action, trade_size, token, exchange, exchange_price, totle_used, totle_price, pct_savings, splits, ex_prices
@functools.lru_cache()
def parse_csv_files(csv_files, **kwargs):
"""Returns 2 dicts containing pct savings and prices/split data both having the form
token: { trade_size: {exchange: [sample, sample, ...], ...}
kwargs have these defaults: only_splits=False, only_non_splits=False
"""
per_token_savings = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
slip_price_diff_splits = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
per_file_base_prices = {}
for _, _, trade_size, token, exchange, exchange_price, _, totle_price, pct_savings, splits, _ in csv_row_gen(file, **kwargs):
if not per_file_base_prices.get(token): # this assumes prices recorded from lowest to highest for a token
per_file_base_prices[token] = totle_price # should be same for all aggs, but is slightly different sometimes
slip = (totle_price / per_file_base_prices[token]) - 1.0 # should be 0 for the lowest trade_size
# i.e. slip = (totle_price - per_file_base_prices[token]) / per_file_base_prices[token]
slip = 0.0 if slip < 0.0 and slip > -0.00001 else slip # get rid of -0.0000
price_diff = (totle_price - exchange_price) / exchange_price
slip_price_diff_splits[token][trade_size][exchange].append((slip, price_diff, splits))
per_token_savings[token][trade_size][exchange].append(pct_savings)
return per_token_savings, slip_price_diff_splits
@functools.lru_cache()
def read_slippage_csvs(csv_files=None):
"""Returns a dict of price_slip_cost data points, i.e. {token: {trade_size: {exchange: [ (psc), (psc) ] }}}"""
csv_files = csv_files or glob.glob(f'{CSV_DATA_DIR}/*buy_slippage.csv')
| for file in csv_files:
print(f"reading {file} ...")
f_exchange, f_token, *_ = os.path.basename(file).split('_')
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
# time,action,trade_size,token,exchange,exchange_price,slippage,cost
for row in reader:
# time = datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size = float(row['trade_size'])
tok_ts_ex_pscs[f_token][trade_size][f_exchange].append( (float(row['exchange_price']), float(row['slippage']), float(row['cost'])) )
return tok_ts_ex_pscs # TODO: don't return defaultdicts, users should get key errors
# generator
def pct_savings_gen(per_pair_savings):
"""Generates a sequence of (pair, trade_size, agg/exchange, [pct_savings]) for all leaves in the given dict"""
for pair, ts_ex_savings in sorted(per_pair_savings.items()):
for trade_size, ex_savings in ts_ex_savings.items():
for exchange, pct_savings in ex_savings.items():
yield pair, trade_size, exchange, pct_savings
########################################################################################################################
# JSON file aggregation functions
DEX_AG = dexag_client.name()
ONE_INCH = oneinch_client.name()
PARASWAP = paraswap_client.name()
TOTLE_EX = totle_client.name()
AGG_NAMES = [DEX_AG, ONE_INCH, PARASWAP]
JSON_DATA_DIR = f"{os.path.dirname(os.path.abspath(__file__))}/order_splitting_data"
@functools.lru_cache()
def get_all_splits_by_agg(files=None):
"""Returns an aggregated dict of split data, i.e. token: {trade_size: {agg: [{dex: pct, dex: pct}, {...}, ...]}}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_splits_by_agg.json')
tok_ts_splits_by_agg = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_splits_by_agg in json.load(open(f)).items():
for ts, agg_splits in ts_splits_by_agg.items():
for agg, split in agg_splits.items():
tok_ts_splits_by_agg[token][ts][agg].append(split)
return dict(sorted(tok_ts_splits_by_agg.items()))
@functools.lru_cache()
def get_all_dexs_with_pair(files=None):
"""Returns an aggregated dict of DEXs used in splits, i.e. token: {trade_size: [dex, dex, ...]}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dexs_with_pair.json')
tok_ts_dexs_with_pair = defaultdict(lambda: defaultdict(list))
for f in files:
for token, ts_dexs_with_pair in json.load(open(f)).items():
for ts, dexs in ts_dexs_with_pair.items():
tok_ts_dexs_with_pair[token][ts] = list(set(tok_ts_dexs_with_pair[token][ts] + dexs))
return dict(sorted(tok_ts_dexs_with_pair.items()))
@functools.lru_cache()
def get_all_agg_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_agg_prices.json')
tok_ts_agg_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
for agg, price in agg_prices.items():
tok_ts_agg_prices[token][ts][agg].append(price)
return dict(sorted(tok_ts_agg_prices.items()))
@functools.lru_cache()
def get_all_dex_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dex_prices.json')
tok_ts_dex_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
# test for agg_name keys because Totle's JSON structure is different from aggs
if any(map(lambda k: k in AGG_NAMES, agg_prices.keys())):
# agg dex_prices files look like this:
# "0.1": {
# "DEX.AG": {
# "Uniswap": 0.003936408446252657,
# "Bancor": 0.003993840558066265
# },
# "Paraswap": { ... }
for agg, prices in agg_prices.items():
tok_ts_dex_prices[token][ts][agg].append(prices)
else:
# Totle's dex_prices file looks like this:
# "0.1": {
# "Ether Delta": 0.00735650292064385,
# "Bancor": 0.003993865645004445,
# "Uniswap": 0.003936433172436365
# },
# "0.5": { ... }
# insert Totle as the agg_name in the aggregated data structure
tok_ts_dex_prices[token][ | tok_ts_ex_pscs = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
| random_line_split |
data_import.py | ={only_non_splits}) ...")
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
for row in reader:
splits = canonicalize_and_sort_splits(row.get('splits'))
totle_splits = canonicalize_and_sort_splits(row.get('totle_splits'))
if only_splits and len(splits) < 2: continue
if only_totle_splits and len(totle_splits) < 2: continue
if only_non_splits and len(splits) > 1: continue
if only_totle_non_splits and len(totle_splits) > 1: continue
id, time, action = row['id'], row['time'], row['action'] # datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size, token = float(row['trade_size']), row['token']
exchange, exchange_price = row['exchange'], float(row['exchange_price'])
totle_used, totle_price, pct_savings = row['totle_used'], float(row['totle_price']), float(row['pct_savings']),
# Some older CSVs have the non-splittable dexs in the ex_prices column
ex_prices = exchange_utils.canonical_and_splittable(eval(row.get('ex_prices') or '{}'))
if pct_savings < -1.0:
print(f"{pct_savings} vs {exchange} buying {token} for {trade_size} ETH using {totle_used} {totle_splits} id={id}")
yield time, action, trade_size, token, exchange, exchange_price, totle_used, totle_price, pct_savings, splits, ex_prices
@functools.lru_cache()
def parse_csv_files(csv_files, **kwargs):
"""Returns 2 dicts containing pct savings and prices/split data both having the form
token: { trade_size: {exchange: [sample, sample, ...], ...}
kwargs have these defaults: only_splits=False, only_non_splits=False
"""
per_token_savings = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
slip_price_diff_splits = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
per_file_base_prices = {}
for _, _, trade_size, token, exchange, exchange_price, _, totle_price, pct_savings, splits, _ in csv_row_gen(file, **kwargs):
if not per_file_base_prices.get(token): # this assumes prices recorded from lowest to highest for a token
per_file_base_prices[token] = totle_price # should be same for all aggs, but is slightly different sometimes
slip = (totle_price / per_file_base_prices[token]) - 1.0 # should be 0 for the lowest trade_size
# i.e. slip = (totle_price - per_file_base_prices[token]) / per_file_base_prices[token]
slip = 0.0 if slip < 0.0 and slip > -0.00001 else slip # get rid of -0.0000
price_diff = (totle_price - exchange_price) / exchange_price
slip_price_diff_splits[token][trade_size][exchange].append((slip, price_diff, splits))
per_token_savings[token][trade_size][exchange].append(pct_savings)
return per_token_savings, slip_price_diff_splits
@functools.lru_cache()
def read_slippage_csvs(csv_files=None):
"""Returns a dict of price_slip_cost data points, i.e. {token: {trade_size: {exchange: [ (psc), (psc) ] }}}"""
csv_files = csv_files or glob.glob(f'{CSV_DATA_DIR}/*buy_slippage.csv')
tok_ts_ex_pscs = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for file in csv_files:
print(f"reading {file} ...")
f_exchange, f_token, *_ = os.path.basename(file).split('_')
with open(file, newline='') as csvfile:
reader = csv.DictReader(csvfile, fieldnames=None)
# time,action,trade_size,token,exchange,exchange_price,slippage,cost
for row in reader:
# time = datetime.fromisoformat(row['time']).isoformat(' ', 'seconds')
trade_size = float(row['trade_size'])
tok_ts_ex_pscs[f_token][trade_size][f_exchange].append( (float(row['exchange_price']), float(row['slippage']), float(row['cost'])) )
return tok_ts_ex_pscs # TODO: don't return defaultdicts, users should get key errors
# generator
def pct_savings_gen(per_pair_savings):
"""Generates a sequence of (pair, trade_size, agg/exchange, [pct_savings]) for all leaves in the given dict"""
for pair, ts_ex_savings in sorted(per_pair_savings.items()):
for trade_size, ex_savings in ts_ex_savings.items():
for exchange, pct_savings in ex_savings.items():
yield pair, trade_size, exchange, pct_savings
########################################################################################################################
# JSON file aggregation functions
DEX_AG = dexag_client.name()
ONE_INCH = oneinch_client.name()
PARASWAP = paraswap_client.name()
TOTLE_EX = totle_client.name()
AGG_NAMES = [DEX_AG, ONE_INCH, PARASWAP]
JSON_DATA_DIR = f"{os.path.dirname(os.path.abspath(__file__))}/order_splitting_data"
@functools.lru_cache()
def | (files=None):
"""Returns an aggregated dict of split data, i.e. token: {trade_size: {agg: [{dex: pct, dex: pct}, {...}, ...]}}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_splits_by_agg.json')
tok_ts_splits_by_agg = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_splits_by_agg in json.load(open(f)).items():
for ts, agg_splits in ts_splits_by_agg.items():
for agg, split in agg_splits.items():
tok_ts_splits_by_agg[token][ts][agg].append(split)
return dict(sorted(tok_ts_splits_by_agg.items()))
@functools.lru_cache()
def get_all_dexs_with_pair(files=None):
"""Returns an aggregated dict of DEXs used in splits, i.e. token: {trade_size: [dex, dex, ...]}"""
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dexs_with_pair.json')
tok_ts_dexs_with_pair = defaultdict(lambda: defaultdict(list))
for f in files:
for token, ts_dexs_with_pair in json.load(open(f)).items():
for ts, dexs in ts_dexs_with_pair.items():
tok_ts_dexs_with_pair[token][ts] = list(set(tok_ts_dexs_with_pair[token][ts] + dexs))
return dict(sorted(tok_ts_dexs_with_pair.items()))
@functools.lru_cache()
def get_all_agg_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_agg_prices.json')
tok_ts_agg_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
for agg, price in agg_prices.items():
tok_ts_agg_prices[token][ts][agg].append(price)
return dict(sorted(tok_ts_agg_prices.items()))
@functools.lru_cache()
def get_all_dex_prices(files=None):
files = files or glob.glob(f'{JSON_DATA_DIR}/2019*ts_dex_prices.json')
tok_ts_dex_prices = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
for f in files:
for token, ts_agg_prices in json.load(open(f)).items():
for ts, agg_prices in ts_agg_prices.items():
# test for agg_name keys because Totle's JSON structure is different from aggs
if any(map(lambda k: k in AGG_NAMES, agg_prices.keys())):
# agg dex_prices files look like this:
# "0.1": {
# "DEX.AG": {
# "Uniswap": 0.003936408446252657,
# "Bancor": 0.003993840558066265
# },
# "Paraswap": { ... }
for agg, prices in agg_prices.items():
tok_ts_dex_prices[token][ts][agg].append(prices)
else:
# Totle's dex_prices file looks like this:
# "0.1": {
# "Ether Delta": 0.00735650292064385,
# "Bancor": 0.003993865645004445,
# "Uniswap": 0.003936433172436365
# },
# "0.5": { ... }
# insert Totle as the agg_name in the aggregated data structure
tok_ts_dex_prices[token][ | get_all_splits_by_agg | identifier_name |
ourairports.rs | _deg: Option<f64>,
/// Longitude of the centre of the high-numbered end of the runway, in decimal degrees (positive is east), if available.
he_longitude_deg: Option<f64>,
/// Elevation above MSL of the high-numbered end of the runway in feet.
he_elevation_ft: Option<i32>,
#[serde(rename = "he_heading_degT")]
/// Heading of the high-numbered end of the runway in degrees true (*not* magnetic).
he_heading_deg_true: Option<f64>,
/// Length of the displaced threshold (if any) for the high-numbered end of the runway, in feet.
he_displaced_threshold_ft: Option<i32>,
}
/// Represents a single radio navigation
#[derive(Deserialize, Serialize)]
pub struct Navaid {
/// Internal OurAirports integer identifier for the navaid.
/// This will stay persistent, even if the navaid identifier or frequency changes.
id: String,
/// This is a unique string identifier constructed from the navaid name and country, and used in the OurAirports URL.
filename: String,
/// The 1-3 character identifer that the navaid transmits.
ident: String,
/// The name of the navaid, excluding its type.
name: String,
/// The type of the navaid. Options are "DME", "NDB", "NDB-DME", "TACAN", "VOR", "VOR-DME", or "VORTAC".
/// See the [map legend](https://ourairports.com/help/data-dictionary.html#navaids) for more information about each type.
#[serde(rename = "type")]
navaid_type: String,
/// The frequency of the navaid in *kilohertz*.
/// If the Navaid operates on the VHF band (VOR, VOR-DME) or operates on the UHF band with a paired VHF frequency (DME, TACAN, VORTAC), then you need to divide this number by 1,000 to get the frequency in megahertz (115.3 MHz in this example).
/// For an NDB or NDB-DME, you can use this frequency directly.
frequency_khz: String,
/// The latitude of the navaid in decimal degrees (negative for south).
latitude_deg: Option<f64>,
/// The longitude of the navaid in decimal degrees (negative for west).
longitude_deg: Option<f64>,
/// The navaid's elevation MSL in feet (not metres).
elevation_ft: Option<i32>,
/// The two-character [ISO 3166:1-alpha2 code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) for the country that operates the navaid.
/// A handful of unofficial, non-ISO codes are also in use, such as "XK" for [Kosovo](https://ourairports.com/countries/XK/).
iso_country: String,
/// The paired VHF frequency for the DME (or TACAN) in kilohertz.
/// Divide by 1,000 to get the paired VHF frequency in megahertz (e.g. 115.3 MHz).
dme_frequency_khz: String,
/// The DME channel (an alternative way of tuning distance-measuring equipment)
dme_channel: String,
/// The latitude of the associated DME in decimal degrees (negative for south). If missing, assume that the value is the same as `latitude_deg`.
dme_latitude_deg: Option<f64>,
/// The longitude of the associated DME in decimal degrees (negative for west). If missing, assume that the value is the same as `longitude_deg`.
dme_longitude_deg: Option<f64>,
/// The associated DME transmitters elevation MSL in feet. If missing, assume that it's the same value as `elevation_ft`.
dme_elevation_ft: Option<i32>,
/// The magnetic variation adjustment built into a VOR's, VOR-DME's, or TACAN's radials. Positive means east (added to the true direction), and negative means west (subtracted from the true direction).
/// This will not usually be the same as `magnetic_variation_deg` because the magnetic pole is constantly in motion.
slaved_variation_deg: Option<f64>,
/// The actual magnetic variation at the navaid's location. Positive means east (added to the true direction), and negative means west (subtracted from the true direction),
magnetic_variation_deg: Option<f64>,
/// The primary function of the navaid in the airspace system.
/// Options include "HI" (high-altitude airways, at or above flight level 180), "LO" (low-altitude airways), "BOTH" (high- and low-altitude airways), "TERM" (terminal-area navigation only), and "RNAV" (non-GPS area navigation).
#[serde(rename = "usageType")]
usage_type: String,
/// The power-output level of the navaid.
/// Options include "HIGH", "MEDIUM", "LOW", and "UNKNOWN".
power: String,
/// The OurAirports text identifier (usually the ICAO code) for an airport associated with the navaid.
/// Links to the `ident` column in airports.csv.
associated_airport: String,
}
/// Represents a country or country-like entity (e.g. Hong Kong)
#[derive(Deserialize, Serialize)]
pub struct Country {
/// Internal OurAirports integer identifier for the country.
/// This will stay persistent, even if the country name or code changes.
id: String,
/// The two-character [ISO 3166:1-alpha2 code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) for the country that operates the navaid.
/// A handful of unofficial, non-ISO codes are also in use, such as "XK" for [Kosovo](https://ourairports.com/countries/XK/).
/// The `iso_country` field in airports.csv points into this field.
code: String,
/// The common **English**-language name for the country.
/// Other variations of the name may appear in the `keywords` field to assist with search.
name: String,
/// The code for the continent where the country is (primarily) located.
/// See the `continent` code in airports.csv for allowed values.
continent: String,
/// Link to the Wikipedia article about the country.
wikipedia_link: String,
/// An array of search keywords/phrases related to the country.
#[serde(deserialize_with = "vec_string_from_string")]
keywords: Vec<String>,
}
/// Represents a high-level administrative subdivision of a country
#[derive(Deserialize, Serialize)]
pub struct Region {
/// Internal OurAirports integer identifier for the region. This will stay persistent, even if the region code changes.
id: String,
/// `local_code` prefixed with the country code to make a globally-unique identifier.
code: String,
/// The local code for the administrative subdivision.
/// Whenever possible, these are official [ISO 3166:2](https://en.wikipedia.org/wiki/ISO_3166-2), at the highest level available, but in some cases OurAirports has to use unofficial codes.
/// There is also a pseudo code "U-A" for each country, which means that the airport has not yet been assigned to a region (or perhaps can't be, as in the case of a deep-sea oil platform).
local_code: String,
/// The common **English**-language name for the administrative subdivision.
/// In some cases, the name in local languages will appear in the `keywords` field assist search.
name: String,
/// A code for the continent to which the region belongs.
/// See the `continent` field in airports.csv for a list of codes.
continent: String,
/// The two-character [ISO 3166:1-alpha2 code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) for the country containing the administrative subdivision.
/// A handful of unofficial, non-ISO codes are also in use, such as "XK" for [Kosovo](https://ourairports.com/countries/XK/).
iso_country: String,
/// A link to the Wikipedia article describing the subdivision.
wikipedia_link: String,
/// An array of keywords to assist with search. May include former names for the region, and/or the region name in other languages.
#[serde(deserialize_with = "vec_string_from_string")]
keywords: Vec<String>,
}
/// Converts a string to a boolean based on "yes" and "no"
fn bool_from_str<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
D: Deserializer<'de>,
{
match String::deserialize(deserializer)?.to_lowercase().as_str() {
"yes" | "1"=> Ok(true),
"no" | "0" => Ok(false),
other => Err(de::Error::invalid_value(
Unexpected::Str(other),
&"Value must be yes or no",
)),
}
}
/// Transforms a comma-separated string to a vector.
fn | vec_string_from_string | identifier_name | |
ourairports.rs | .
municipality: String,
/// true if the airport currently has scheduled airline service; false otherwise.
#[serde(deserialize_with = "bool_from_str")]
scheduled_service: bool,
/// The code that an aviation GPS database (such as Jeppesen's or Garmin's) would normally use for the airport. This will always be the ICAO code if one exists.
/// Note that, unlike the `ident` column, this is *not* guaranteed to be globally unique.
gps_code: String,
/// The three-letter IATA code for the airport (if it has one).
iata_code: String,
/// The local country code for the airport, if different from the `gps_code` and `iata_code` fields (used mainly for US airports).
local_code: String,
/// URL of the airport's official home page on the web, if one exists.
home_link: String,
/// URL of the airport's page on Wikipedia, if one exists.
wikipedia_link: String,
/// Extra keywords/phrases to assist with search, as a Vec.
/// May include former names for the airport, alternate codes, names in other languages, nearby tourist destinations, etc.
#[serde(deserialize_with = "vec_string_from_string")] | /// for voice communication (radio navigation aids appear in struct Navaids)
#[derive(Deserialize, Serialize)]
pub struct AirportFrequency {
/// Internal OurAirports integer identifier for the frequency.
/// This will stay persistent, even if the radio frequency or description changes.
id: String,
/// Internal integer foreign key matching the `id` column for the associated airport in Airports struct.
/// (`airport_ident` is a better alternative.)
airport_ref: String,
/// Externally-visible string foreign key matching the `ident` column for the associated airport in Airports.
airport_ident: String,
/// A code for the frequency type.
/// This isn't (currently) a controlled vocabulary, but probably will be soon.
/// Some common values are "TWR" (tower), "ATF" or "CTAF" (common traffic frequency), "GND" (ground control), "RMP" (ramp control), "ATIS" (automated weather), "RCO" (remote radio outlet), "ARR" (arrivals), "DEP" (departures), "UNICOM" (monitored ground station), and "RDO" (a flight-service station).
#[serde(rename = "type")]
frequency_type: String,
/// A description of the frequency, typically the way a pilot would open a call on it.
description: String,
/// Radio voice frequency in megahertz.
/// Note that the same frequency may appear multiple times for an airport, serving different functions.
frequency_mhz: String,
}
/// Contains information about a single landing surface
#[derive(Deserialize, Serialize)]
pub struct Runway {
/// Internal OurAirports integer identifier for the runway.
/// This will stay persistent, even if the runway numbering changes.
id: String,
/// Internal integer foreign key matching the id column for the associated airport in airports.csv. (`airport_ident` is a better alternative.)
airport_ref: String,
/// Externally-visible string foreign key matching the ident column for the associated airport in airports.csv.
airport_ident: String,
/// Length of the full runway surface (including displaced thresholds, overrun areas, etc) in feet.
length_ft: Option<u32>,
/// Width of the runway surface in feet.
width_ft: Option<u32>,
/// Code for the runway surface type.
/// This is not yet a controlled vocabulary, but probably will be soon.
/// Some common values include "ASP" (asphalt), "TURF" (turf), "CON" (concrete), "GRS" (grass), "GRE" (gravel), "WATER" (water), and "UNK" (unknown).
surface: String,
/// `true` if the surface is lighted at night. `false` otherwise.
#[serde(deserialize_with = "bool_from_str")]
lighted: bool,
/// `true` if the runway surface is currently closed, `false` otherwise.
#[serde(deserialize_with = "bool_from_str")]
closed: bool,
/// Identifier for the low-numbered end of the runway.
le_ident: String,
/// Latitude of the centre of the low-numbered end of the runway, in decimal degrees (positive is north), if available.
le_latitude_deg: Option<f64>,
/// Longitude of the centre of the low-numbered end of the runway, in decimal degrees (positive is east), if available.
le_longitude_deg: Option<f64>,
/// Elevation above MSL of the low-numbered end of the runway in feet.
le_elevation_ft: Option<i32>,
/// Heading of the low-numbered end of the runway in degrees true (*not* magnetic).
#[serde(rename = "le_heading_degT")]
le_heading_deg_true: Option<f64>,
/// Length of the displaced threshold (if any) for the low-numbered end of the runway, in feet.
le_displaced_threshold_ft: Option<i32>,
/// Identifier for the high-numbered end of the runway.
he_ident: String,
/// Latitude of the centre of the high-numbered end of the runway, in decimal degrees (positive is north), if available.
he_latitude_deg: Option<f64>,
/// Longitude of the centre of the high-numbered end of the runway, in decimal degrees (positive is east), if available.
he_longitude_deg: Option<f64>,
/// Elevation above MSL of the high-numbered end of the runway in feet.
he_elevation_ft: Option<i32>,
#[serde(rename = "he_heading_degT")]
/// Heading of the high-numbered end of the runway in degrees true (*not* magnetic).
he_heading_deg_true: Option<f64>,
/// Length of the displaced threshold (if any) for the high-numbered end of the runway, in feet.
he_displaced_threshold_ft: Option<i32>,
}
/// Represents a single radio navigation
#[derive(Deserialize, Serialize)]
pub struct Navaid {
/// Internal OurAirports integer identifier for the navaid.
/// This will stay persistent, even if the navaid identifier or frequency changes.
id: String,
/// This is a unique string identifier constructed from the navaid name and country, and used in the OurAirports URL.
filename: String,
/// The 1-3 character identifer that the navaid transmits.
ident: String,
/// The name of the navaid, excluding its type.
name: String,
/// The type of the navaid. Options are "DME", "NDB", "NDB-DME", "TACAN", "VOR", "VOR-DME", or "VORTAC".
/// See the [map legend](https://ourairports.com/help/data-dictionary.html#navaids) for more information about each type.
#[serde(rename = "type")]
navaid_type: String,
/// The frequency of the navaid in *kilohertz*.
/// If the Navaid operates on the VHF band (VOR, VOR-DME) or operates on the UHF band with a paired VHF frequency (DME, TACAN, VORTAC), then you need to divide this number by 1,000 to get the frequency in megahertz (115.3 MHz in this example).
/// For an NDB or NDB-DME, you can use this frequency directly.
frequency_khz: String,
/// The latitude of the navaid in decimal degrees (negative for south).
latitude_deg: Option<f64>,
/// The longitude of the navaid in decimal degrees (negative for west).
longitude_deg: Option<f64>,
/// The navaid's elevation MSL in feet (not metres).
elevation_ft: Option<i32>,
/// The two-character [ISO 3166:1-alpha2 code](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) for the country that operates the navaid.
/// A handful of unofficial, non-ISO codes are also in use, such as "XK" for [Kosovo](https://ourairports.com/countries/XK/).
iso_country: String,
/// The paired VHF frequency for the DME (or TACAN) in kilohertz.
/// Divide by 1,000 to get the paired VHF frequency in megahertz (e.g. 115.3 MHz).
dme_frequency_khz: String,
/// The DME channel (an alternative way of tuning distance-measuring equipment)
dme_channel: String,
/// The latitude of the associated DME in decimal degrees (negative for south). If missing, assume that the value is the same as `latitude_deg`.
dme_latitude_deg: Option<f64>,
/// The longitude of the associated DME in decimal degrees (negative for west). If missing, assume that the value is the same as `longitude_deg`.
dme_longitude_deg: Option<f64>,
/// The associated DME transmitters elevation MSL in feet. If missing, assume that it's the same value | keywords: Vec<String>,
}
/// Contains information about a single airport radio frequency | random_line_split |
num_format.rs | with this source code.
// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
//! handles creating printed output for numeric substitutions
// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
use std::env;
use std::vec::Vec;
use crate::display::Quotable;
use crate::{show_error, show_warning};
use super::format_field::{FieldType, FormatField};
use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
use super::formatters::cninetyninehexfloatf::CninetyNineHexFloatf;
use super::formatters::decf::Decf;
use super::formatters::floatf::Floatf;
use super::formatters::intf::Intf;
use super::formatters::scif::Scif;
pub fn warn_expected_numeric(pf_arg: &str) {
// important: keep println here not print
show_error!("{}: expected a numeric value", pf_arg.maybe_quote());
}
// when character constant arguments have excess characters
// issue a warning when POSIXLY_CORRECT is not set
fn warn_char_constant_ign(remaining_bytes: &[u8]) {
match env::var("POSIXLY_CORRECT") {
Ok(_) => {}
Err(e) => {
if let env::VarError::NotPresent = e {
show_warning!(
"{:?}: character(s) following character \
constant have been ignored",
remaining_bytes
);
}
}
}
}
// this function looks at the first few
// characters of an argument and returns a value if we can learn
// a value from that (e.g. no argument? return 0, char constant? ret value)
fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
const C_S_QUOTE: u8 = 39;
const C_D_QUOTE: u8 = 34;
match str_in_opt {
Some(str_in) => {
let mut byte_it = str_in.bytes();
if let Some(ch) = byte_it.next() {
match ch {
C_S_QUOTE | C_D_QUOTE => {
Some(match byte_it.next() {
Some(second_byte) => {
let mut ignored: Vec<u8> = Vec::new();
for cont in byte_it {
ignored.push(cont);
}
if !ignored.is_empty() {
warn_char_constant_ign(&ignored);
}
second_byte
}
// no byte after quote
None => {
let so_far = (ch as char).to_string();
warn_expected_numeric(&so_far);
0_u8
}
})
}
// first byte is not quote
_ => None, // no first byte
}
} else {
Some(0_u8)
}
}
None => Some(0),
}
}
// takes a string and returns
// a sign,
// a base,
// and an offset for index after all
// initial spacing, sign, base prefix, and leading zeroes
#[allow(clippy::cognitive_complexity)]
fn get_initial_prefix(str_in: &str, field_type: &FieldType) -> InitialPrefix {
let mut str_it = str_in.chars();
let mut ret = InitialPrefix {
radix_in: Base::Ten,
sign: 1,
offset: 0,
};
let mut top_char = str_it.next();
// skip spaces and ensure top_char is the first non-space char
// (or None if none exists)
while let Some(' ') = top_char {
ret.offset += 1;
top_char = str_it.next();
}
// parse sign
match top_char {
Some('+') => {
ret.offset += 1;
top_char = str_it.next();
}
Some('-') => {
ret.sign = -1;
ret.offset += 1;
top_char = str_it.next();
}
_ => {}
}
// we want to exit with offset being
// the index of the first non-zero
// digit before the decimal point or
// if there is none, the zero before the
// decimal point, or, if there is none,
// the decimal point.
// while we are determining the offset
// we will ensure as a convention
// the offset is always on the first character
// that we are yet unsure if it is the
// final offset. If the zero could be before
// a decimal point we don't move past the zero.
let mut is_hex = false;
if Some('0') == top_char {
if let Some(base) = str_it.next() {
// lead zeroes can only exist in
// octal and hex base
let mut do_clean_lead_zeroes = false;
match base {
'x' | 'X' => {
is_hex = true;
ret.offset += 2;
ret.radix_in = Base::Hex;
do_clean_lead_zeroes = true;
}
e @ '0'..='9' => {
ret.offset += 1;
if let FieldType::Intf = *field_type {
ret.radix_in = Base::Octal;
}
if e == '0' {
do_clean_lead_zeroes = true;
}
}
_ => {}
}
if do_clean_lead_zeroes {
let mut first = true;
for ch_zero in str_it {
// see notes on offset above:
// this is why the offset for octal and decimal numbers
// that reach this branch is 1 even though
// they have already eaten the characters '00'
// this is also why when hex encounters its
// first zero it does not move its offset
// forward because it does not know for sure
// that it's current offset (of that zero)
// is not the final offset,
// whereas at that point octal knows its
// current offset is not the final offset.
match ch_zero {
'0' => {
if !(is_hex && first) {
ret.offset += 1;
}
}
// if decimal, keep last zero if one exists
// (it's possible for last zero to
// not exist at this branch if we're in hex input)
'.' => break,
// other digit, etc.
_ => {
if !(is_hex && first) {
ret.offset += 1;
}
break;
}
}
if first {
first = false;
}
}
}
}
}
ret
}
// this is the function a Sub's print will delegate to
// if it is a numeric field, passing the field details
// and an iterator to the argument
pub fn | (field: &FormatField, in_str_opt: Option<&String>) -> Option<String> {
let field_char = field.field_char;
// num format mainly operates by further delegating to one of
// several Formatter structs depending on the field
// see formatter.rs for more details
// to do switch to static dispatch
let formatter: Box<dyn Formatter> = match *field.field_type {
FieldType::Intf => Box::new(Intf::new()),
FieldType::Floatf => Box::new(Floatf::new()),
FieldType::CninetyNineHexFloatf => Box::new(CninetyNineHexFloatf::new()),
FieldType::Scif => Box::new(Scif::new()),
FieldType::Decf => Box::new(Decf::new()),
_ => {
panic!("asked to do num format with non-num field type");
}
};
let prim_opt=
// if we can get an assumed value from looking at the first
// few characters, use that value to create the FormatPrimitive
if let Some(provided_num) = get_provided(in_str_opt) {
let mut tmp = FormatPrimitive::default();
match field_char {
'u' | 'i' | 'd' => {
tmp.pre_decimal = Some(
format!("{provided_num}"));
},
'x' | 'X' => {
tmp.pre_decimal = Some(
format!("{provided_num:x}"));
},
'o' => {
tmp.pre_decimal = Some(
format!("{provided_num:o}"));
},
'e' | 'E' | 'g' | 'G' => {
let as_str = format!("{provided_num}");
let initial_prefix = get_initial_prefix(
&as_str,
field.field_type
);
tmp=formatter.get_primitive(field, &initial_prefix, &as_str)
.expect("err during default provided num");
},
_ => {
tmp.pre_decimal = Some(
format!("{provided_num}"));
tmp.post_decimal = Some(String::from("0"));
}
}
Some(tmp)
} else {
// otherwise we'll interpret the argument as a number
// using the appropriate Formatter
let in_str = in_str_opt.expect(
"please send the devs this message:
\n get_provided is failing to ret as Some(0) on no str ");
// first get information about the beginning of the
// numeric argument that would be useful for
// any formatter (int or float)
let initial_prefix = get_initial_prefix(
in | num_format | identifier_name |
num_format.rs | with this source code.
// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
//! handles creating printed output for numeric substitutions
// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
use std::env;
use std::vec::Vec;
use crate::display::Quotable;
use crate::{show_error, show_warning};
use super::format_field::{FieldType, FormatField};
use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
use super::formatters::cninetyninehexfloatf::CninetyNineHexFloatf;
use super::formatters::decf::Decf;
use super::formatters::floatf::Floatf;
use super::formatters::intf::Intf;
use super::formatters::scif::Scif;
pub fn warn_expected_numeric(pf_arg: &str) |
// when character constant arguments have excess characters
// issue a warning when POSIXLY_CORRECT is not set
fn warn_char_constant_ign(remaining_bytes: &[u8]) {
match env::var("POSIXLY_CORRECT") {
Ok(_) => {}
Err(e) => {
if let env::VarError::NotPresent = e {
show_warning!(
"{:?}: character(s) following character \
constant have been ignored",
remaining_bytes
);
}
}
}
}
// this function looks at the first few
// characters of an argument and returns a value if we can learn
// a value from that (e.g. no argument? return 0, char constant? ret value)
fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
const C_S_QUOTE: u8 = 39;
const C_D_QUOTE: u8 = 34;
match str_in_opt {
Some(str_in) => {
let mut byte_it = str_in.bytes();
if let Some(ch) = byte_it.next() {
match ch {
C_S_QUOTE | C_D_QUOTE => {
Some(match byte_it.next() {
Some(second_byte) => {
let mut ignored: Vec<u8> = Vec::new();
for cont in byte_it {
ignored.push(cont);
}
if !ignored.is_empty() {
warn_char_constant_ign(&ignored);
}
second_byte
}
// no byte after quote
None => {
let so_far = (ch as char).to_string();
warn_expected_numeric(&so_far);
0_u8
}
})
}
// first byte is not quote
_ => None, // no first byte
}
} else {
Some(0_u8)
}
}
None => Some(0),
}
}
// takes a string and returns
// a sign,
// a base,
// and an offset for index after all
// initial spacing, sign, base prefix, and leading zeroes
#[allow(clippy::cognitive_complexity)]
fn get_initial_prefix(str_in: &str, field_type: &FieldType) -> InitialPrefix {
let mut str_it = str_in.chars();
let mut ret = InitialPrefix {
radix_in: Base::Ten,
sign: 1,
offset: 0,
};
let mut top_char = str_it.next();
// skip spaces and ensure top_char is the first non-space char
// (or None if none exists)
while let Some(' ') = top_char {
ret.offset += 1;
top_char = str_it.next();
}
// parse sign
match top_char {
Some('+') => {
ret.offset += 1;
top_char = str_it.next();
}
Some('-') => {
ret.sign = -1;
ret.offset += 1;
top_char = str_it.next();
}
_ => {}
}
// we want to exit with offset being
// the index of the first non-zero
// digit before the decimal point or
// if there is none, the zero before the
// decimal point, or, if there is none,
// the decimal point.
// while we are determining the offset
// we will ensure as a convention
// the offset is always on the first character
// that we are yet unsure if it is the
// final offset. If the zero could be before
// a decimal point we don't move past the zero.
let mut is_hex = false;
if Some('0') == top_char {
if let Some(base) = str_it.next() {
// lead zeroes can only exist in
// octal and hex base
let mut do_clean_lead_zeroes = false;
match base {
'x' | 'X' => {
is_hex = true;
ret.offset += 2;
ret.radix_in = Base::Hex;
do_clean_lead_zeroes = true;
}
e @ '0'..='9' => {
ret.offset += 1;
if let FieldType::Intf = *field_type {
ret.radix_in = Base::Octal;
}
if e == '0' {
do_clean_lead_zeroes = true;
}
}
_ => {}
}
if do_clean_lead_zeroes {
let mut first = true;
for ch_zero in str_it {
// see notes on offset above:
// this is why the offset for octal and decimal numbers
// that reach this branch is 1 even though
// they have already eaten the characters '00'
// this is also why when hex encounters its
// first zero it does not move its offset
// forward because it does not know for sure
// that it's current offset (of that zero)
// is not the final offset,
// whereas at that point octal knows its
// current offset is not the final offset.
match ch_zero {
'0' => {
if !(is_hex && first) {
ret.offset += 1;
}
}
// if decimal, keep last zero if one exists
// (it's possible for last zero to
// not exist at this branch if we're in hex input)
'.' => break,
// other digit, etc.
_ => {
if !(is_hex && first) {
ret.offset += 1;
}
break;
}
}
if first {
first = false;
}
}
}
}
}
ret
}
// this is the function a Sub's print will delegate to
// if it is a numeric field, passing the field details
// and an iterator to the argument
pub fn num_format(field: &FormatField, in_str_opt: Option<&String>) -> Option<String> {
let field_char = field.field_char;
// num format mainly operates by further delegating to one of
// several Formatter structs depending on the field
// see formatter.rs for more details
// to do switch to static dispatch
let formatter: Box<dyn Formatter> = match *field.field_type {
FieldType::Intf => Box::new(Intf::new()),
FieldType::Floatf => Box::new(Floatf::new()),
FieldType::CninetyNineHexFloatf => Box::new(CninetyNineHexFloatf::new()),
FieldType::Scif => Box::new(Scif::new()),
FieldType::Decf => Box::new(Decf::new()),
_ => {
panic!("asked to do num format with non-num field type");
}
};
let prim_opt=
// if we can get an assumed value from looking at the first
// few characters, use that value to create the FormatPrimitive
if let Some(provided_num) = get_provided(in_str_opt) {
let mut tmp = FormatPrimitive::default();
match field_char {
'u' | 'i' | 'd' => {
tmp.pre_decimal = Some(
format!("{provided_num}"));
},
'x' | 'X' => {
tmp.pre_decimal = Some(
format!("{provided_num:x}"));
},
'o' => {
tmp.pre_decimal = Some(
format!("{provided_num:o}"));
},
'e' | 'E' | 'g' | 'G' => {
let as_str = format!("{provided_num}");
let initial_prefix = get_initial_prefix(
&as_str,
field.field_type
);
tmp=formatter.get_primitive(field, &initial_prefix, &as_str)
.expect("err during default provided num");
},
_ => {
tmp.pre_decimal = Some(
format!("{provided_num}"));
tmp.post_decimal = Some(String::from("0"));
}
}
Some(tmp)
} else {
// otherwise we'll interpret the argument as a number
// using the appropriate Formatter
let in_str = in_str_opt.expect(
"please send the devs this message:
\n get_provided is failing to ret as Some(0) on no str ");
// first get information about the beginning of the
// numeric argument that would be useful for
// any formatter (int or float)
let initial_prefix = get_initial_prefix(
| {
// important: keep println here not print
show_error!("{}: expected a numeric value", pf_arg.maybe_quote());
} | identifier_body |
num_format.rs | distributed with this source code.
// spell-checker:ignore (vars) charf cninetyninehexfloatf decf floatf intf scif strf Cninety
//! handles creating printed output for numeric substitutions
// spell-checker:ignore (vars) charf decf floatf intf scif strf Cninety
use std::env;
use std::vec::Vec;
use crate::display::Quotable;
use crate::{show_error, show_warning};
use super::format_field::{FieldType, FormatField};
use super::formatter::{Base, FormatPrimitive, Formatter, InitialPrefix};
use super::formatters::cninetyninehexfloatf::CninetyNineHexFloatf;
use super::formatters::decf::Decf;
use super::formatters::floatf::Floatf;
use super::formatters::intf::Intf;
use super::formatters::scif::Scif;
pub fn warn_expected_numeric(pf_arg: &str) {
// important: keep println here not print
show_error!("{}: expected a numeric value", pf_arg.maybe_quote());
}
// when character constant arguments have excess characters
// issue a warning when POSIXLY_CORRECT is not set
fn warn_char_constant_ign(remaining_bytes: &[u8]) {
match env::var("POSIXLY_CORRECT") {
Ok(_) => {}
Err(e) => {
if let env::VarError::NotPresent = e {
show_warning!(
"{:?}: character(s) following character \
constant have been ignored",
remaining_bytes
);
}
}
}
}
// this function looks at the first few
// characters of an argument and returns a value if we can learn
// a value from that (e.g. no argument? return 0, char constant? ret value)
fn get_provided(str_in_opt: Option<&String>) -> Option<u8> {
const C_S_QUOTE: u8 = 39;
const C_D_QUOTE: u8 = 34;
match str_in_opt {
Some(str_in) => {
let mut byte_it = str_in.bytes();
if let Some(ch) = byte_it.next() {
match ch {
C_S_QUOTE | C_D_QUOTE => {
Some(match byte_it.next() {
Some(second_byte) => {
let mut ignored: Vec<u8> = Vec::new();
for cont in byte_it {
ignored.push(cont);
}
if !ignored.is_empty() {
warn_char_constant_ign(&ignored);
}
second_byte
}
// no byte after quote
None => {
let so_far = (ch as char).to_string();
warn_expected_numeric(&so_far);
0_u8
}
})
}
// first byte is not quote
_ => None, // no first byte
}
} else {
Some(0_u8)
}
}
None => Some(0),
}
}
// takes a string and returns
// a sign,
// a base,
// and an offset for index after all
// initial spacing, sign, base prefix, and leading zeroes
#[allow(clippy::cognitive_complexity)]
fn get_initial_prefix(str_in: &str, field_type: &FieldType) -> InitialPrefix {
let mut str_it = str_in.chars();
let mut ret = InitialPrefix {
radix_in: Base::Ten,
sign: 1,
offset: 0,
};
let mut top_char = str_it.next();
// skip spaces and ensure top_char is the first non-space char
// (or None if none exists)
while let Some(' ') = top_char {
ret.offset += 1;
top_char = str_it.next();
}
// parse sign
match top_char {
Some('+') => {
ret.offset += 1;
top_char = str_it.next();
}
Some('-') => {
ret.sign = -1; | ret.offset += 1;
top_char = str_it.next();
}
_ => {}
}
// we want to exit with offset being
// the index of the first non-zero
// digit before the decimal point or
// if there is none, the zero before the
// decimal point, or, if there is none,
// the decimal point.
// while we are determining the offset
// we will ensure as a convention
// the offset is always on the first character
// that we are yet unsure if it is the
// final offset. If the zero could be before
// a decimal point we don't move past the zero.
let mut is_hex = false;
if Some('0') == top_char {
if let Some(base) = str_it.next() {
// lead zeroes can only exist in
// octal and hex base
let mut do_clean_lead_zeroes = false;
match base {
'x' | 'X' => {
is_hex = true;
ret.offset += 2;
ret.radix_in = Base::Hex;
do_clean_lead_zeroes = true;
}
e @ '0'..='9' => {
ret.offset += 1;
if let FieldType::Intf = *field_type {
ret.radix_in = Base::Octal;
}
if e == '0' {
do_clean_lead_zeroes = true;
}
}
_ => {}
}
if do_clean_lead_zeroes {
let mut first = true;
for ch_zero in str_it {
// see notes on offset above:
// this is why the offset for octal and decimal numbers
// that reach this branch is 1 even though
// they have already eaten the characters '00'
// this is also why when hex encounters its
// first zero it does not move its offset
// forward because it does not know for sure
// that it's current offset (of that zero)
// is not the final offset,
// whereas at that point octal knows its
// current offset is not the final offset.
match ch_zero {
'0' => {
if !(is_hex && first) {
ret.offset += 1;
}
}
// if decimal, keep last zero if one exists
// (it's possible for last zero to
// not exist at this branch if we're in hex input)
'.' => break,
// other digit, etc.
_ => {
if !(is_hex && first) {
ret.offset += 1;
}
break;
}
}
if first {
first = false;
}
}
}
}
}
ret
}
// this is the function a Sub's print will delegate to
// if it is a numeric field, passing the field details
// and an iterator to the argument
pub fn num_format(field: &FormatField, in_str_opt: Option<&String>) -> Option<String> {
let field_char = field.field_char;
// num format mainly operates by further delegating to one of
// several Formatter structs depending on the field
// see formatter.rs for more details
// to do switch to static dispatch
let formatter: Box<dyn Formatter> = match *field.field_type {
FieldType::Intf => Box::new(Intf::new()),
FieldType::Floatf => Box::new(Floatf::new()),
FieldType::CninetyNineHexFloatf => Box::new(CninetyNineHexFloatf::new()),
FieldType::Scif => Box::new(Scif::new()),
FieldType::Decf => Box::new(Decf::new()),
_ => {
panic!("asked to do num format with non-num field type");
}
};
let prim_opt=
// if we can get an assumed value from looking at the first
// few characters, use that value to create the FormatPrimitive
if let Some(provided_num) = get_provided(in_str_opt) {
let mut tmp = FormatPrimitive::default();
match field_char {
'u' | 'i' | 'd' => {
tmp.pre_decimal = Some(
format!("{provided_num}"));
},
'x' | 'X' => {
tmp.pre_decimal = Some(
format!("{provided_num:x}"));
},
'o' => {
tmp.pre_decimal = Some(
format!("{provided_num:o}"));
},
'e' | 'E' | 'g' | 'G' => {
let as_str = format!("{provided_num}");
let initial_prefix = get_initial_prefix(
&as_str,
field.field_type
);
tmp=formatter.get_primitive(field, &initial_prefix, &as_str)
.expect("err during default provided num");
},
_ => {
tmp.pre_decimal = Some(
format!("{provided_num}"));
tmp.post_decimal = Some(String::from("0"));
}
}
Some(tmp)
} else {
// otherwise we'll interpret the argument as a number
// using the appropriate Formatter
let in_str = in_str_opt.expect(
"please send the devs this message:
\n get_provided is failing to ret as Some(0) on no str ");
// first get information about the beginning of the
// numeric argument that would be useful for
// any formatter (int or float)
let initial_prefix = get_initial_prefix(
in | random_line_split | |
qaoaLibrary.py | si)
retvalue = 0
for k in range(Neigs):
retvalue += overlap(final, vec[:,k])**2
return np.sqrt(retvalue)
#betagamma = all betas first, then all gammas
def expectQAOAp(psi, H, betagamma):
ppsi = pointer(psi)
pH = pointer(H)
qc.uniform(ppsi)
p = len(betagamma)/2
qc.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
return qc.expectH(psi, pH)
# return squared overlap with the ground state vectors
def overlapQAOAp(psi, H, betagamma, vec):
ppsi = pointer(psi)
pH = pointer(H)
csp.uniform(ppsi)
p = len(betagamma)/2
csp.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
sqoverlap=0
psivec = c2pyState(psi)
for i in len(vec.T):
sqoverlap += overlap(psivec, vec[:,i])**2
return sqoverlap
# Perform an inductive local optimization of QAOA angles. The code returns
# optimal angles and energy. Psi is now the result of the optimal evolution.
def optQAOA(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 0.5*np.ones(2)
bgCur= bg0
for p in range(1,pmax+1):
bgNew = np.concatenate((bgCur[:p-1], [bgCur[p-1]], bgCur[p-1:], [bgCur[-1]]))
opt = minimize(fOpt, bg0 if p==1 else bgNew, method=typeOfOpt)
bgCur = opt.x
E = expectQAOAp(psi, H, bgCur.tolist())
#if E!=opt.fun: return "Error: Energy expectation does not match optimized value"
return (bgCur, E)
def optQAOAglobal(psi, H, p, Nit=10, Temp=1.0, Tmax=20):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 2.0*np.ones(2*p)
bounds = [(0,pi/2)]*p + [(0,np.inf)]*p
minKwargs = dict(method="L-BFGS-B", bounds=bounds)
stepCond = MaxTbound(Tmax)
opt = basinhopping(fOpt, bg0, niter=Nit, T=Temp, minimizer_kwargs=minKwargs, accept_test=stepCond)
bgOpt= opt.x
E = expectQAOAp(psi, H, bgOpt.tolist())
return (opt.x, E)
# Full search of angles, with resolution of M for every pi/2 angles
# beta range: [0,pi/2]
# Gamma range: [0, 3*pi]
def optQAOAgreedy(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
bg0 = [0.5]*2
bgOpt = []
for p in range(pmax):
fOpt = lambda bg: expectQAOAp(psi, H, np.concatenate((bgOpt,bg)).tolist())
opt = minimize(fOpt, bg0, method=typeOfOpt)
bgOpt += opt.x.tolist()
E = expectQAOAp(psi, H, bgOpt)
return (np.array(bgOpt), E)
def optQAOAfull(psi, H, p, M=10, trunc=-np.inf):
S = 2 # scale factor gamma:beta
bMax = pi/2
gMax = S*bMax
indOpt= np.inf
Opt = np.inf
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, S*M,endpoint=False)]*p))
for ind, i in enumerate(configs):
Ecur = expectQAOAp(psi, H, i)
if trunc!=np.inf and Ecur < trunc:
Opt = Ecur
indOpt = ind
break
indOpt= indOpt if Opt < Ecur else ind
Opt = min(Opt, Ecur)
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, 6*M,endpoint=False)]*p))
return (list(configs)[indOpt], Opt)
# Prints useful information
def printOut(psi, val, vec, bgOpt, Eopt):
final = c2pyState(psi)
final2gs = 0
sumval = 0
Neigs = len(vec.T)
for k in range(Neigs):
sumval += overlap(final, vec[:,k])**2
final2gs=np.sqrt(sumval)
final2initial = 1./sqrt(psi.N)*overlap(final, np.ones(psi.N))
print "Optimal schedule:",
for i in range(len(bgOpt)):
print "%5.4f "%bgOpt[i],
print
#print "%5.4f %5.4f"%(Eopt, val[0])
print "Energy ratio: %7.6f, Overlap: %5.4f"%(np.abs(Eopt/(val[0])), final2gs)
print "Final to initial state overlap: %5.4f"%final2initial
# Symmetrize a state w.r.t to the global Z2 symmetry present in 2-local Hamiltonians
# Only physical when you are in the symmetric sector
def z2symmetrize(psi):
sym = psi + psi[::-1]
return sym/np.sqrt(overlap(sym,sym))
# Entanglement entropy
# Input: a state psi (as an np.arrar) in the computational basis, and the cut site k
def entent(psi, k):
N = len(psi)
n = len(format(N,'b'))-1 # effectively n = log2(N) for powers of two
m = n-k
prho = np.zeros((1<<k,1<<k),dtype=np.complex_) # partial density matrix
x = np.arange(1<<k)
for i in range(1<<m):
ppsi = psi[x*(1<<m)+i] # Partial state vector
prho += np.outer(ppsi,np.conj(ppsi))
val, vec = eigh(prho)
return sum(map(lambda x: -x*np.log(abs(x)+0.000000000001), val))
# The analytical formula for energy under QAOA1
# betagamma = beta first, then gamma
def expectQAOA1(H, betagamma):
return qc.qaoa1energy(byref(H), c_double(betagamma[0]), c_double(betagamma[1]))
##############################################################################
# ZZ + X + Z Hamiltonian coefficient generators
# Output format: a list of lists of the form ((Z, ZZ, ..), (X, XX, ..))
# So, for a 2 local Hamiltonian, expect ((Z, ZZ), (X,))
# The standard 2-local long-range model with power law interactions
def lr(n, alpha, J, B):
Ki = np.zeros(n)
Jij = np.array([[(J/(abs(i-j))**alpha if i!=j else 0) for i in range(n)] for j in range(n)])
Bi = B*np.ones(n)
return ((Ki, Jij), (Bi,))
# Read parameters and prepare coefficients
def readParams():
return
# Construct an unweighted MaxSat instance from a cnf file
# NOTE1: cnf Clauses must be 1-indexed.
# NOTE2: This method is pretty memory-inefficient for
# large clause sizes. Ideal for up to ~4Sat
def readCnf(path2file):
f=open(path2file,'r')
clauses = []
maxLength = 0
while True:
line = f.readline()
if not line: break
spline = line.split()
if spline[0]=='c':
continue
elif spline[0]=='p':
n = int(spline[2])
M = int(spline[3])
else:
for c in spline[:-1]:
if abs(int(c))>n or int(c)==0:
print("Error: variable indices must lie between 0 and %d"%n) | break;
if spline[-1]!='0':
print("Error: clause descriptions must have a terminal 0") | random_line_split | |
qaoaLibrary.py | with bounds"""
def __init__(self, T, stepsize=0.5):
self.maxT= T
def __call__(self, **kwargs):
"""take a random step but ensure the new position is within the bounds"""
x = kwargs["x_new"]
return (sum(x)<self.maxT)
# Set input and return types
qc.expectH.restype = c_double
qc.overlap.resype = c_double
qc.energy.restype = c_double
qc.qaoa1energy.restype = c_double
# Initialize state and hamiltonian
def | (n):
psi = state()
H = ham()
qc.allocate(byref(psi),n)
qc.allocateH(byref(H),n)
return (psi, H)
# Generate Ham object from coefficients zzc, xc and zc (given as np arrays)
def hamGen(H, zzc, xc, zc):
n = len(xc)
H.zzc = (c_double * n**2)(*zzc.flatten().tolist())
H.xc = (c_double * n)(*xc.tolist())
H.zc = (c_double * n)(*zc.tolist())
# Function to compute Ham's k smallest eigenvalues and eigenvectors
def ground(H, Neigs):
n = H.n
energies= map(lambda i:qc.energy(i,byref(H)), range(1<<n))
Ham = np.diag(energies)
for i in range(1<<n):
for j in range(n):
Ham[i,i^(1<<j)] = H.xc[j]
return sp.linalg.eigsh(Ham, k=Neigs, which='SA')
# Inner product magnitude of two states given as complex np arrays
def overlap(psi1, psi2):
return np.abs(np.vdot(psi1,psi2))
# Convert C state object into numpy array of computational basis amplitudes
def c2pyState(psi):
n = psi.n
return np.array(psi.realcur[:1<<n]) + 1.0j*np.array(psi.imagcur[:1<<n])
# Overlap of psi with the Neigs smallest ground states of H
def gsOverlap(psi, H, Neigs):
val, vec = ground(H, Neigs)
final = c2pyState(psi)
retvalue = 0
for k in range(Neigs):
retvalue += overlap(final, vec[:,k])**2
return np.sqrt(retvalue)
#betagamma = all betas first, then all gammas
def expectQAOAp(psi, H, betagamma):
ppsi = pointer(psi)
pH = pointer(H)
qc.uniform(ppsi)
p = len(betagamma)/2
qc.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
return qc.expectH(psi, pH)
# return squared overlap with the ground state vectors
def overlapQAOAp(psi, H, betagamma, vec):
ppsi = pointer(psi)
pH = pointer(H)
csp.uniform(ppsi)
p = len(betagamma)/2
csp.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
sqoverlap=0
psivec = c2pyState(psi)
for i in len(vec.T):
sqoverlap += overlap(psivec, vec[:,i])**2
return sqoverlap
# Perform an inductive local optimization of QAOA angles. The code returns
# optimal angles and energy. Psi is now the result of the optimal evolution.
def optQAOA(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 0.5*np.ones(2)
bgCur= bg0
for p in range(1,pmax+1):
bgNew = np.concatenate((bgCur[:p-1], [bgCur[p-1]], bgCur[p-1:], [bgCur[-1]]))
opt = minimize(fOpt, bg0 if p==1 else bgNew, method=typeOfOpt)
bgCur = opt.x
E = expectQAOAp(psi, H, bgCur.tolist())
#if E!=opt.fun: return "Error: Energy expectation does not match optimized value"
return (bgCur, E)
def optQAOAglobal(psi, H, p, Nit=10, Temp=1.0, Tmax=20):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 2.0*np.ones(2*p)
bounds = [(0,pi/2)]*p + [(0,np.inf)]*p
minKwargs = dict(method="L-BFGS-B", bounds=bounds)
stepCond = MaxTbound(Tmax)
opt = basinhopping(fOpt, bg0, niter=Nit, T=Temp, minimizer_kwargs=minKwargs, accept_test=stepCond)
bgOpt= opt.x
E = expectQAOAp(psi, H, bgOpt.tolist())
return (opt.x, E)
# Full search of angles, with resolution of M for every pi/2 angles
# beta range: [0,pi/2]
# Gamma range: [0, 3*pi]
def optQAOAgreedy(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
bg0 = [0.5]*2
bgOpt = []
for p in range(pmax):
fOpt = lambda bg: expectQAOAp(psi, H, np.concatenate((bgOpt,bg)).tolist())
opt = minimize(fOpt, bg0, method=typeOfOpt)
bgOpt += opt.x.tolist()
E = expectQAOAp(psi, H, bgOpt)
return (np.array(bgOpt), E)
def optQAOAfull(psi, H, p, M=10, trunc=-np.inf):
S = 2 # scale factor gamma:beta
bMax = pi/2
gMax = S*bMax
indOpt= np.inf
Opt = np.inf
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, S*M,endpoint=False)]*p))
for ind, i in enumerate(configs):
Ecur = expectQAOAp(psi, H, i)
if trunc!=np.inf and Ecur < trunc:
Opt = Ecur
indOpt = ind
break
indOpt= indOpt if Opt < Ecur else ind
Opt = min(Opt, Ecur)
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, 6*M,endpoint=False)]*p))
return (list(configs)[indOpt], Opt)
# Prints useful information
def printOut(psi, val, vec, bgOpt, Eopt):
final = c2pyState(psi)
final2gs = 0
sumval = 0
Neigs = len(vec.T)
for k in range(Neigs):
sumval += overlap(final, vec[:,k])**2
final2gs=np.sqrt(sumval)
final2initial = 1./sqrt(psi.N)*overlap(final, np.ones(psi.N))
print "Optimal schedule:",
for i in range(len(bgOpt)):
print "%5.4f "%bgOpt[i],
print
#print "%5.4f %5.4f"%(Eopt, val[0])
print "Energy ratio: %7.6f, Overlap: %5.4f"%(np.abs(Eopt/(val[0])), final2gs)
print "Final to initial state overlap: %5.4f"%final2initial
# Symmetrize a state w.r.t to the global Z2 symmetry present in 2-local Hamiltonians
# Only physical when you are in the symmetric sector
def z2symmetrize(psi):
sym = psi + psi[::-1]
return sym/np.sqrt(overlap(sym,sym))
# Entanglement entropy
# Input: a state psi (as an np.arrar) in the computational basis, and the cut site k
def entent(psi, k):
N = len(psi)
n = len(format(N,'b'))-1 # effectively n = log2(N) for powers of two
m = n-k
prho = np.zeros((1<<k,1<<k),dtype=np.complex_) # partial density matrix
x = np.arange(1<<k)
for i in range(1<<m):
| initialize | identifier_name |
qaoaLibrary.py |
# Set input and return types
qc.expectH.restype = c_double
qc.overlap.resype = c_double
qc.energy.restype = c_double
qc.qaoa1energy.restype = c_double
# Initialize state and hamiltonian
def initialize(n):
psi = state()
H = ham()
qc.allocate(byref(psi),n)
qc.allocateH(byref(H),n)
return (psi, H)
# Generate Ham object from coefficients zzc, xc and zc (given as np arrays)
def hamGen(H, zzc, xc, zc):
n = len(xc)
H.zzc = (c_double * n**2)(*zzc.flatten().tolist())
H.xc = (c_double * n)(*xc.tolist())
H.zc = (c_double * n)(*zc.tolist())
# Function to compute Ham's k smallest eigenvalues and eigenvectors
def ground(H, Neigs):
n = H.n
energies= map(lambda i:qc.energy(i,byref(H)), range(1<<n))
Ham = np.diag(energies)
for i in range(1<<n):
for j in range(n):
Ham[i,i^(1<<j)] = H.xc[j]
return sp.linalg.eigsh(Ham, k=Neigs, which='SA')
# Inner product magnitude of two states given as complex np arrays
def overlap(psi1, psi2):
return np.abs(np.vdot(psi1,psi2))
# Convert C state object into numpy array of computational basis amplitudes
def c2pyState(psi):
n = psi.n
return np.array(psi.realcur[:1<<n]) + 1.0j*np.array(psi.imagcur[:1<<n])
# Overlap of psi with the Neigs smallest ground states of H
def gsOverlap(psi, H, Neigs):
val, vec = ground(H, Neigs)
final = c2pyState(psi)
retvalue = 0
for k in range(Neigs):
retvalue += overlap(final, vec[:,k])**2
return np.sqrt(retvalue)
#betagamma = all betas first, then all gammas
def expectQAOAp(psi, H, betagamma):
ppsi = pointer(psi)
pH = pointer(H)
qc.uniform(ppsi)
p = len(betagamma)/2
qc.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
return qc.expectH(psi, pH)
# return squared overlap with the ground state vectors
def overlapQAOAp(psi, H, betagamma, vec):
ppsi = pointer(psi)
pH = pointer(H)
csp.uniform(ppsi)
p = len(betagamma)/2
csp.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
sqoverlap=0
psivec = c2pyState(psi)
for i in len(vec.T):
sqoverlap += overlap(psivec, vec[:,i])**2
return sqoverlap
# Perform an inductive local optimization of QAOA angles. The code returns
# optimal angles and energy. Psi is now the result of the optimal evolution.
def optQAOA(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 0.5*np.ones(2)
bgCur= bg0
for p in range(1,pmax+1):
bgNew = np.concatenate((bgCur[:p-1], [bgCur[p-1]], bgCur[p-1:], [bgCur[-1]]))
opt = minimize(fOpt, bg0 if p==1 else bgNew, method=typeOfOpt)
bgCur = opt.x
E = expectQAOAp(psi, H, bgCur.tolist())
#if E!=opt.fun: return "Error: Energy expectation does not match optimized value"
return (bgCur, E)
def optQAOAglobal(psi, H, p, Nit=10, Temp=1.0, Tmax=20):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 2.0*np.ones(2*p)
bounds = [(0,pi/2)]*p + [(0,np.inf)]*p
minKwargs = dict(method="L-BFGS-B", bounds=bounds)
stepCond = MaxTbound(Tmax)
opt = basinhopping(fOpt, bg0, niter=Nit, T=Temp, minimizer_kwargs=minKwargs, accept_test=stepCond)
bgOpt= opt.x
E = expectQAOAp(psi, H, bgOpt.tolist())
return (opt.x, E)
# Full search of angles, with resolution of M for every pi/2 angles
# beta range: [0,pi/2]
# Gamma range: [0, 3*pi]
def optQAOAgreedy(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
bg0 = [0.5]*2
bgOpt = []
for p in range(pmax):
fOpt = lambda bg: expectQAOAp(psi, H, np.concatenate((bgOpt,bg)).tolist())
opt = minimize(fOpt, bg0, method=typeOfOpt)
bgOpt += opt.x.tolist()
E = expectQAOAp(psi, H, bgOpt)
return (np.array(bgOpt), E)
def optQAOAfull(psi, H, p, M=10, trunc=-np.inf):
S = 2 # scale factor gamma:beta
bMax = pi/2
gMax = S*bMax
indOpt= np.inf
Opt = np.inf
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, S*M,endpoint=False)]*p))
for ind, i in enumerate(configs):
Ecur = expectQAOAp(psi, H, i)
if trunc!=np.inf and Ecur < trunc:
Opt = Ecur
indOpt = ind
break
indOpt= indOpt if Opt < Ecur else ind
Opt = min(Opt, Ecur)
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, 6*M,endpoint=False)]*p))
return (list(configs)[indOpt], Opt)
# Prints useful information
def printOut(psi, val, vec, bgOpt, Eopt):
final = c2pyState(psi)
final2gs = 0
sumval = 0
Neigs = len(vec.T)
for k in range(Neigs):
sumval += overlap(final, vec[:,k])**2
final2gs=np.sqrt(sumval)
final2initial = 1./sqrt(psi.N)*overlap(final, np.ones(psi.N))
print "Optimal schedule:",
for i in range(len(bgOpt)):
print "%5.4f "%bgOpt[i],
print
#print "%5.4f %5.4f"%(Eopt, val[0])
print "Energy ratio: %7.6f, Overlap: %5.4f"%(np.abs(Eopt/(val[0])), final2gs)
print "Final to initial state overlap: %5.4f"%final2initial
# Symmetrize a state w.r.t to the global Z2 symmetry present in 2-local Hamiltonians
# Only physical when you are in the symmetric sector
def z2symmetrize(psi):
sym = psi + psi[::-1]
return sym/np.sqrt(overlap(sym,sym))
# Entanglement entropy
# Input: a state psi (as an np.arrar) in the computational basis, and the cut site k
def entent(psi, k):
N = len(psi)
n = len(format(N,'b'))-1 # effectively n = log2(N) for powers of two
m = n-k
prho = np.zeros((1<<k,1<<k),dtype=np.complex_) # partial density matrix
x = np.arange(1<<k)
for i in range(1<< | """random displacement with bounds"""
def __init__(self, T, stepsize=0.5):
self.maxT= T
def __call__(self, **kwargs):
"""take a random step but ensure the new position is within the bounds"""
x = kwargs["x_new"]
return (sum(x)<self.maxT) | identifier_body | |
qaoaLibrary.py | igs):
val, vec = ground(H, Neigs)
final = c2pyState(psi)
retvalue = 0
for k in range(Neigs):
retvalue += overlap(final, vec[:,k])**2
return np.sqrt(retvalue)
#betagamma = all betas first, then all gammas
def expectQAOAp(psi, H, betagamma):
ppsi = pointer(psi)
pH = pointer(H)
qc.uniform(ppsi)
p = len(betagamma)/2
qc.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
return qc.expectH(psi, pH)
# return squared overlap with the ground state vectors
def overlapQAOAp(psi, H, betagamma, vec):
ppsi = pointer(psi)
pH = pointer(H)
csp.uniform(ppsi)
p = len(betagamma)/2
csp.evolveQAOA(ppsi, pH, (c_double * p)(*betagamma[:p]), (c_double * p)(*betagamma[p:]), p)
sqoverlap=0
psivec = c2pyState(psi)
for i in len(vec.T):
sqoverlap += overlap(psivec, vec[:,i])**2
return sqoverlap
# Perform an inductive local optimization of QAOA angles. The code returns
# optimal angles and energy. Psi is now the result of the optimal evolution.
def optQAOA(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 0.5*np.ones(2)
bgCur= bg0
for p in range(1,pmax+1):
bgNew = np.concatenate((bgCur[:p-1], [bgCur[p-1]], bgCur[p-1:], [bgCur[-1]]))
opt = minimize(fOpt, bg0 if p==1 else bgNew, method=typeOfOpt)
bgCur = opt.x
E = expectQAOAp(psi, H, bgCur.tolist())
#if E!=opt.fun: return "Error: Energy expectation does not match optimized value"
return (bgCur, E)
def optQAOAglobal(psi, H, p, Nit=10, Temp=1.0, Tmax=20):
ppsi = pointer(psi)
pH = pointer(H)
fOpt = lambda bg: expectQAOAp(psi, H, bg.tolist())
bg0 = 2.0*np.ones(2*p)
bounds = [(0,pi/2)]*p + [(0,np.inf)]*p
minKwargs = dict(method="L-BFGS-B", bounds=bounds)
stepCond = MaxTbound(Tmax)
opt = basinhopping(fOpt, bg0, niter=Nit, T=Temp, minimizer_kwargs=minKwargs, accept_test=stepCond)
bgOpt= opt.x
E = expectQAOAp(psi, H, bgOpt.tolist())
return (opt.x, E)
# Full search of angles, with resolution of M for every pi/2 angles
# beta range: [0,pi/2]
# Gamma range: [0, 3*pi]
def optQAOAgreedy(psi, H, pmax, typeOfOpt='BFGS'):
ppsi = pointer(psi)
pH = pointer(H)
bg0 = [0.5]*2
bgOpt = []
for p in range(pmax):
fOpt = lambda bg: expectQAOAp(psi, H, np.concatenate((bgOpt,bg)).tolist())
opt = minimize(fOpt, bg0, method=typeOfOpt)
bgOpt += opt.x.tolist()
E = expectQAOAp(psi, H, bgOpt)
return (np.array(bgOpt), E)
def optQAOAfull(psi, H, p, M=10, trunc=-np.inf):
S = 2 # scale factor gamma:beta
bMax = pi/2
gMax = S*bMax
indOpt= np.inf
Opt = np.inf
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, S*M,endpoint=False)]*p))
for ind, i in enumerate(configs):
Ecur = expectQAOAp(psi, H, i)
if trunc!=np.inf and Ecur < trunc:
Opt = Ecur
indOpt = ind
break
indOpt= indOpt if Opt < Ecur else ind
Opt = min(Opt, Ecur)
configs = it.product(*([np.linspace(0,bMax, M,endpoint=False)]*p + [np.linspace(0,gMax, 6*M,endpoint=False)]*p))
return (list(configs)[indOpt], Opt)
# Prints useful information
def printOut(psi, val, vec, bgOpt, Eopt):
final = c2pyState(psi)
final2gs = 0
sumval = 0
Neigs = len(vec.T)
for k in range(Neigs):
sumval += overlap(final, vec[:,k])**2
final2gs=np.sqrt(sumval)
final2initial = 1./sqrt(psi.N)*overlap(final, np.ones(psi.N))
print "Optimal schedule:",
for i in range(len(bgOpt)):
print "%5.4f "%bgOpt[i],
print
#print "%5.4f %5.4f"%(Eopt, val[0])
print "Energy ratio: %7.6f, Overlap: %5.4f"%(np.abs(Eopt/(val[0])), final2gs)
print "Final to initial state overlap: %5.4f"%final2initial
# Symmetrize a state w.r.t to the global Z2 symmetry present in 2-local Hamiltonians
# Only physical when you are in the symmetric sector
def z2symmetrize(psi):
sym = psi + psi[::-1]
return sym/np.sqrt(overlap(sym,sym))
# Entanglement entropy
# Input: a state psi (as an np.arrar) in the computational basis, and the cut site k
def entent(psi, k):
N = len(psi)
n = len(format(N,'b'))-1 # effectively n = log2(N) for powers of two
m = n-k
prho = np.zeros((1<<k,1<<k),dtype=np.complex_) # partial density matrix
x = np.arange(1<<k)
for i in range(1<<m):
ppsi = psi[x*(1<<m)+i] # Partial state vector
prho += np.outer(ppsi,np.conj(ppsi))
val, vec = eigh(prho)
return sum(map(lambda x: -x*np.log(abs(x)+0.000000000001), val))
# The analytical formula for energy under QAOA1
# betagamma = beta first, then gamma
def expectQAOA1(H, betagamma):
return qc.qaoa1energy(byref(H), c_double(betagamma[0]), c_double(betagamma[1]))
##############################################################################
# ZZ + X + Z Hamiltonian coefficient generators
# Output format: a list of lists of the form ((Z, ZZ, ..), (X, XX, ..))
# So, for a 2 local Hamiltonian, expect ((Z, ZZ), (X,))
# The standard 2-local long-range model with power law interactions
def lr(n, alpha, J, B):
Ki = np.zeros(n)
Jij = np.array([[(J/(abs(i-j))**alpha if i!=j else 0) for i in range(n)] for j in range(n)])
Bi = B*np.ones(n)
return ((Ki, Jij), (Bi,))
# Read parameters and prepare coefficients
def readParams():
return
# Construct an unweighted MaxSat instance from a cnf file
# NOTE1: cnf Clauses must be 1-indexed.
# NOTE2: This method is pretty memory-inefficient for
# large clause sizes. Ideal for up to ~4Sat
def readCnf(path2file):
f=open(path2file,'r')
clauses = []
maxLength = 0
while True:
line = f.readline()
if not line: break
spline = line.split()
if spline[0]=='c':
continue
elif spline[0]=='p':
n = int(spline[2])
M = int(spline[3])
else:
for c in spline[:-1]:
if abs(int(c))>n or int(c)==0:
| print("Error: variable indices must lie between 0 and %d"%n)
break; | conditional_block | |
publish.rs | subcommand.
//!
use std::convert::TryFrom;
use std::path::PathBuf;
use std::str::FromStr;
use colored::Colorize;
use structopt::StructOpt;
use zksync::web3::types::H256;
use zksync_eth_signer::PrivateKeySigner;
use zksync_types::tx::PackedEthSignature;
use crate::error::Error;
use crate::executable::compiler::Compiler;
use crate::executable::virtual_machine::VirtualMachine;
use crate::http::downloader::Downloader;
use crate::http::Client as HttpClient;
use crate::network::Network;
use crate::project::data::input::Input as InputFile;
use crate::project::data::private_key::PrivateKey as PrivateKeyFile;
use crate::project::data::verifying_key::VerifyingKey as VerifyingKeyFile;
use crate::project::data::Directory as DataDirectory;
use crate::project::src::Directory as SourceDirectory;
use crate::project::target::bytecode::Bytecode as BytecodeFile;
use crate::project::target::deps::Directory as TargetDependenciesDirectory;
use crate::project::target::Directory as TargetDirectory;
///
/// The Zargo package manager `publish` subcommand.
///
#[derive(Debug, StructOpt)]
#[structopt(about = "Uploads the smart contract to the specified network")]
pub struct Command {
/// Prints more logs, if passed several times.
#[structopt(short = "v", long = "verbose", parse(from_occurrences))]
pub verbosity: usize,
/// Suppresses output, if set.
#[structopt(short = "q", long = "quiet")]
pub quiet: bool,
/// The path to the Zinc project manifest file.
#[structopt(
long = "manifest-path",
parse(from_os_str),
default_value = "./Zargo.toml"
)]
pub manifest_path: PathBuf,
/// Sets the contract instance name.
#[structopt(long = "instance")]
pub instance: String,
/// Sets the network name, where the contract must be published to.
#[structopt(long = "network", default_value = "localhost")]
pub network: String,
/// Sets the change-pubkey fee token.
#[structopt(long = "change-pubkey-fee-token", default_value = "ETH")]
pub change_pubkey_fee_token: String,
}
///
/// The publish data. Used for testing purposes.
///
pub struct Data {
/// The address of the published contract instance.
pub address: zksync_types::Address,
/// The account ID of the published contract instance.
pub account_id: zksync_types::AccountId,
}
impl Data {
///
/// A shortcut constructor.
///
pub fn new(address: zksync_types::Address, account_id: zksync_types::AccountId) -> Self {
Self {
address,
account_id,
}
}
}
impl Command {
///
/// A shortcut constructor.
///
pub fn new(
verbosity: usize,
quiet: bool,
manifest_path: PathBuf,
instance: String,
network: Option<String>,
change_pubkey_fee_token: Option<String>,
) -> Self {
Self {
verbosity,
quiet,
manifest_path,
instance,
network: network
.unwrap_or_else(|| Network::from(zksync::Network::Localhost).to_string()),
change_pubkey_fee_token: change_pubkey_fee_token.unwrap_or_else(|| "ETH".to_owned()),
}
}
///
/// Executes the command.
///
pub async fn execute(self) -> anyhow::Result<Data> {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let manifest = zinc_project::Manifest::try_from(&self.manifest_path)?;
match manifest.project.r#type {
zinc_project::ProjectType::Contract => {}
_ => anyhow::bail!(Error::NotAContract),
}
let mut manifest_path = self.manifest_path;
if manifest_path.is_file() {
manifest_path.pop();
}
if let zinc_project::ProjectType::Contract = manifest.project.r#type {
if !PrivateKeyFile::exists_at(&manifest_path) {
PrivateKeyFile::default().write_to(&manifest_path)?;
}
}
let source_directory_path = SourceDirectory::path(&manifest_path);
let source =
zinc_project::Source::try_from_path(&source_directory_path, &manifest_path, true)?;
let project = zinc_project::Project::new(manifest.clone(), source);
DataDirectory::create(&manifest_path)?;
let data_directory_path = DataDirectory::path(&manifest_path);
let mut input_path = data_directory_path.clone();
input_path.push(format!(
"{}.{}",
zinc_const::file_name::INPUT,
zinc_const::extension::JSON,
));
let mut proving_key_path = data_directory_path.clone();
proving_key_path.push(zinc_const::file_name::PROVING_KEY);
let mut verifying_key_path = data_directory_path.clone();
verifying_key_path.push(zinc_const::file_name::VERIFYING_KEY.to_owned());
TargetDirectory::create(&manifest_path, true)?;
let target_directory_path = TargetDirectory::path(&manifest_path, true);
let mut binary_path = target_directory_path;
binary_path.push(format!(
"{}.{}",
zinc_const::file_name::BINARY,
zinc_const::extension::BINARY
));
TargetDependenciesDirectory::create(&manifest_path)?;
if let Some(dependencies) = manifest.dependencies {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let mut downloader = Downloader::new(&http_client, &manifest_path);
downloader.download_dependency_list(dependencies).await?;
}
Compiler::build_release(
self.verbosity,
self.quiet,
manifest.project.name.as_str(),
&manifest.project.version,
&manifest_path,
false,
)?;
let bytecode = BytecodeFile::try_from_path(&binary_path, true)?;
let input = InputFile::try_from_path(&input_path)?;
let arguments = input
.inner
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get("arguments")
.cloned()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get(zinc_const::contract::CONSTRUCTOR_IDENTIFIER)
.cloned()
.ok_or_else(|| {
Error::MissingInputSection(zinc_const::contract::CONSTRUCTOR_IDENTIFIER.to_owned())
})?;
if !verifying_key_path.exists() |
let verifying_key = VerifyingKeyFile::try_from(&verifying_key_path)?;
if !self.quiet {
eprintln!(
" {} the instance `{}` of `{} v{}` to network `{}`",
"Uploading".bright_green(),
self.instance,
manifest.project.name,
manifest.project.version,
network,
);
}
let response = http_client
.publish(
zinc_types::PublishRequestQuery::new(
manifest.project.name,
manifest.project.version,
self.instance,
self.change_pubkey_fee_token.clone(),
),
zinc_types::PublishRequestBody::new(
project,
bytecode.inner,
arguments,
verifying_key.inner,
),
)
.await?;
if !self.quiet {
eprintln!(
" {} {}",
"Address".bright_green(),
serde_json::to_string(&response.address)
.expect(zinc_const::panic::DATA_CONVERSION)
.replace("\"", "")
);
}
let private_key = PrivateKeyFile::try_from(&manifest_path)?;
let signer_private_key: H256 = private_key.inner.parse()?;
let signer_address = PackedEthSignature::address_from_private_key(&signer_private_key)?;
let wallet_credentials = zksync::WalletCredentials::from_eth_signer(
signer_address,
PrivateKeySigner::new(signer_private_key),
network.into(),
)
.await
.expect(zinc_const::panic::DATA_CONVERSION);
let wallet =
zksync::Wallet::new(zksync::RpcProvider::new(network.into()), wallet_credentials)
.await?;
let initial_transfer = crate::transaction::new_initial(
&wallet,
response.address,
self.change_pubkey_fee_token,
response.change_pubkey_fee,
)
.await?;
let address = response.address;
let response = http_client
.initialize(
zinc_types::InitializeRequestQuery::new(response.address),
zinc_types::InitializeRequestBody::new(initial_transfer),
)
.await?;
if !self.quiet {
eprintln!(" {} {}", "Account ID | {
VirtualMachine::setup_contract(
self.verbosity,
self.quiet,
&binary_path,
zinc_const::contract::CONSTRUCTOR_IDENTIFIER,
&proving_key_path,
&verifying_key_path,
)?;
} | conditional_block |
publish.rs | ` subcommand.
//!
use std::convert::TryFrom;
use std::path::PathBuf;
use std::str::FromStr;
use colored::Colorize;
use structopt::StructOpt;
use zksync::web3::types::H256;
use zksync_eth_signer::PrivateKeySigner;
use zksync_types::tx::PackedEthSignature;
use crate::error::Error;
use crate::executable::compiler::Compiler;
use crate::executable::virtual_machine::VirtualMachine;
use crate::http::downloader::Downloader;
use crate::http::Client as HttpClient;
use crate::network::Network;
use crate::project::data::input::Input as InputFile;
use crate::project::data::private_key::PrivateKey as PrivateKeyFile;
use crate::project::data::verifying_key::VerifyingKey as VerifyingKeyFile;
use crate::project::data::Directory as DataDirectory;
use crate::project::src::Directory as SourceDirectory;
use crate::project::target::bytecode::Bytecode as BytecodeFile;
use crate::project::target::deps::Directory as TargetDependenciesDirectory;
use crate::project::target::Directory as TargetDirectory;
///
/// The Zargo package manager `publish` subcommand.
///
#[derive(Debug, StructOpt)]
#[structopt(about = "Uploads the smart contract to the specified network")]
pub struct Command {
/// Prints more logs, if passed several times.
#[structopt(short = "v", long = "verbose", parse(from_occurrences))]
pub verbosity: usize,
/// Suppresses output, if set.
#[structopt(short = "q", long = "quiet")]
pub quiet: bool,
/// The path to the Zinc project manifest file.
#[structopt(
long = "manifest-path",
parse(from_os_str),
default_value = "./Zargo.toml"
)]
pub manifest_path: PathBuf,
/// Sets the contract instance name.
#[structopt(long = "instance")]
pub instance: String,
/// Sets the network name, where the contract must be published to.
#[structopt(long = "network", default_value = "localhost")]
pub network: String,
/// Sets the change-pubkey fee token.
#[structopt(long = "change-pubkey-fee-token", default_value = "ETH")]
pub change_pubkey_fee_token: String,
}
///
/// The publish data. Used for testing purposes.
///
pub struct Data {
/// The address of the published contract instance.
pub address: zksync_types::Address,
/// The account ID of the published contract instance.
pub account_id: zksync_types::AccountId,
}
impl Data {
///
/// A shortcut constructor.
///
pub fn new(address: zksync_types::Address, account_id: zksync_types::AccountId) -> Self {
Self {
address,
account_id,
}
}
}
impl Command {
///
/// A shortcut constructor.
///
pub fn new(
verbosity: usize,
quiet: bool,
manifest_path: PathBuf,
instance: String,
network: Option<String>,
change_pubkey_fee_token: Option<String>,
) -> Self {
Self {
verbosity,
quiet,
manifest_path,
instance,
network: network
.unwrap_or_else(|| Network::from(zksync::Network::Localhost).to_string()),
change_pubkey_fee_token: change_pubkey_fee_token.unwrap_or_else(|| "ETH".to_owned()),
}
}
///
/// Executes the command.
///
pub async fn execute(self) -> anyhow::Result<Data> {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let manifest = zinc_project::Manifest::try_from(&self.manifest_path)?;
match manifest.project.r#type {
zinc_project::ProjectType::Contract => {}
_ => anyhow::bail!(Error::NotAContract),
}
let mut manifest_path = self.manifest_path;
if manifest_path.is_file() {
manifest_path.pop();
}
if let zinc_project::ProjectType::Contract = manifest.project.r#type {
if !PrivateKeyFile::exists_at(&manifest_path) {
PrivateKeyFile::default().write_to(&manifest_path)?;
}
}
let source_directory_path = SourceDirectory::path(&manifest_path);
let source =
zinc_project::Source::try_from_path(&source_directory_path, &manifest_path, true)?;
let project = zinc_project::Project::new(manifest.clone(), source);
DataDirectory::create(&manifest_path)?;
let data_directory_path = DataDirectory::path(&manifest_path);
let mut input_path = data_directory_path.clone();
input_path.push(format!(
"{}.{}",
zinc_const::file_name::INPUT,
zinc_const::extension::JSON,
));
let mut proving_key_path = data_directory_path.clone();
proving_key_path.push(zinc_const::file_name::PROVING_KEY);
let mut verifying_key_path = data_directory_path.clone();
verifying_key_path.push(zinc_const::file_name::VERIFYING_KEY.to_owned());
TargetDirectory::create(&manifest_path, true)?;
let target_directory_path = TargetDirectory::path(&manifest_path, true);
let mut binary_path = target_directory_path;
binary_path.push(format!(
"{}.{}",
zinc_const::file_name::BINARY,
zinc_const::extension::BINARY
));
TargetDependenciesDirectory::create(&manifest_path)?;
if let Some(dependencies) = manifest.dependencies {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let mut downloader = Downloader::new(&http_client, &manifest_path);
downloader.download_dependency_list(dependencies).await?;
}
Compiler::build_release(
self.verbosity,
self.quiet,
manifest.project.name.as_str(),
&manifest.project.version,
&manifest_path,
false,
)?;
let bytecode = BytecodeFile::try_from_path(&binary_path, true)?;
let input = InputFile::try_from_path(&input_path)?;
let arguments = input
.inner
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get("arguments")
.cloned()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get(zinc_const::contract::CONSTRUCTOR_IDENTIFIER)
.cloned()
.ok_or_else(|| {
Error::MissingInputSection(zinc_const::contract::CONSTRUCTOR_IDENTIFIER.to_owned())
})?;
if !verifying_key_path.exists() {
VirtualMachine::setup_contract(
self.verbosity,
self.quiet,
&binary_path,
zinc_const::contract::CONSTRUCTOR_IDENTIFIER,
&proving_key_path,
&verifying_key_path,
)?;
}
let verifying_key = VerifyingKeyFile::try_from(&verifying_key_path)?;
if !self.quiet {
eprintln!(
" {} the instance `{}` of `{} v{}` to network `{}`",
"Uploading".bright_green(),
self.instance,
manifest.project.name,
manifest.project.version,
network,
);
}
let response = http_client
.publish(
zinc_types::PublishRequestQuery::new(
manifest.project.name,
manifest.project.version,
self.instance,
self.change_pubkey_fee_token.clone(),
),
zinc_types::PublishRequestBody::new(
project,
bytecode.inner,
arguments,
verifying_key.inner,
),
)
.await?;
if !self.quiet {
eprintln!(
" {} {}",
"Address".bright_green(),
serde_json::to_string(&response.address)
.expect(zinc_const::panic::DATA_CONVERSION)
.replace("\"", "")
);
}
let private_key = PrivateKeyFile::try_from(&manifest_path)?;
let signer_private_key: H256 = private_key.inner.parse()?;
let signer_address = PackedEthSignature::address_from_private_key(&signer_private_key)?;
let wallet_credentials = zksync::WalletCredentials::from_eth_signer(
signer_address,
PrivateKeySigner::new(signer_private_key),
network.into(),
)
.await
.expect(zinc_const::panic::DATA_CONVERSION); | let initial_transfer = crate::transaction::new_initial(
&wallet,
response.address,
self.change_pubkey_fee_token,
response.change_pubkey_fee,
)
.await?;
let address = response.address;
let response = http_client
.initialize(
zinc_types::InitializeRequestQuery::new(response.address),
zinc_types::InitializeRequestBody::new(initial_transfer),
)
.await?;
if !self.quiet {
eprintln!(" {} {}", "Account ID". | let wallet =
zksync::Wallet::new(zksync::RpcProvider::new(network.into()), wallet_credentials)
.await?;
| random_line_split |
publish.rs | subcommand.
//!
use std::convert::TryFrom;
use std::path::PathBuf;
use std::str::FromStr;
use colored::Colorize;
use structopt::StructOpt;
use zksync::web3::types::H256;
use zksync_eth_signer::PrivateKeySigner;
use zksync_types::tx::PackedEthSignature;
use crate::error::Error;
use crate::executable::compiler::Compiler;
use crate::executable::virtual_machine::VirtualMachine;
use crate::http::downloader::Downloader;
use crate::http::Client as HttpClient;
use crate::network::Network;
use crate::project::data::input::Input as InputFile;
use crate::project::data::private_key::PrivateKey as PrivateKeyFile;
use crate::project::data::verifying_key::VerifyingKey as VerifyingKeyFile;
use crate::project::data::Directory as DataDirectory;
use crate::project::src::Directory as SourceDirectory;
use crate::project::target::bytecode::Bytecode as BytecodeFile;
use crate::project::target::deps::Directory as TargetDependenciesDirectory;
use crate::project::target::Directory as TargetDirectory;
///
/// The Zargo package manager `publish` subcommand.
///
#[derive(Debug, StructOpt)]
#[structopt(about = "Uploads the smart contract to the specified network")]
pub struct Command {
/// Prints more logs, if passed several times.
#[structopt(short = "v", long = "verbose", parse(from_occurrences))]
pub verbosity: usize,
/// Suppresses output, if set.
#[structopt(short = "q", long = "quiet")]
pub quiet: bool,
/// The path to the Zinc project manifest file.
#[structopt(
long = "manifest-path",
parse(from_os_str),
default_value = "./Zargo.toml"
)]
pub manifest_path: PathBuf,
/// Sets the contract instance name.
#[structopt(long = "instance")]
pub instance: String,
/// Sets the network name, where the contract must be published to.
#[structopt(long = "network", default_value = "localhost")]
pub network: String,
/// Sets the change-pubkey fee token.
#[structopt(long = "change-pubkey-fee-token", default_value = "ETH")]
pub change_pubkey_fee_token: String,
}
///
/// The publish data. Used for testing purposes.
///
pub struct Data {
/// The address of the published contract instance.
pub address: zksync_types::Address,
/// The account ID of the published contract instance.
pub account_id: zksync_types::AccountId,
}
impl Data {
///
/// A shortcut constructor.
///
pub fn new(address: zksync_types::Address, account_id: zksync_types::AccountId) -> Self |
}
impl Command {
///
/// A shortcut constructor.
///
pub fn new(
verbosity: usize,
quiet: bool,
manifest_path: PathBuf,
instance: String,
network: Option<String>,
change_pubkey_fee_token: Option<String>,
) -> Self {
Self {
verbosity,
quiet,
manifest_path,
instance,
network: network
.unwrap_or_else(|| Network::from(zksync::Network::Localhost).to_string()),
change_pubkey_fee_token: change_pubkey_fee_token.unwrap_or_else(|| "ETH".to_owned()),
}
}
///
/// Executes the command.
///
pub async fn execute(self) -> anyhow::Result<Data> {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let manifest = zinc_project::Manifest::try_from(&self.manifest_path)?;
match manifest.project.r#type {
zinc_project::ProjectType::Contract => {}
_ => anyhow::bail!(Error::NotAContract),
}
let mut manifest_path = self.manifest_path;
if manifest_path.is_file() {
manifest_path.pop();
}
if let zinc_project::ProjectType::Contract = manifest.project.r#type {
if !PrivateKeyFile::exists_at(&manifest_path) {
PrivateKeyFile::default().write_to(&manifest_path)?;
}
}
let source_directory_path = SourceDirectory::path(&manifest_path);
let source =
zinc_project::Source::try_from_path(&source_directory_path, &manifest_path, true)?;
let project = zinc_project::Project::new(manifest.clone(), source);
DataDirectory::create(&manifest_path)?;
let data_directory_path = DataDirectory::path(&manifest_path);
let mut input_path = data_directory_path.clone();
input_path.push(format!(
"{}.{}",
zinc_const::file_name::INPUT,
zinc_const::extension::JSON,
));
let mut proving_key_path = data_directory_path.clone();
proving_key_path.push(zinc_const::file_name::PROVING_KEY);
let mut verifying_key_path = data_directory_path.clone();
verifying_key_path.push(zinc_const::file_name::VERIFYING_KEY.to_owned());
TargetDirectory::create(&manifest_path, true)?;
let target_directory_path = TargetDirectory::path(&manifest_path, true);
let mut binary_path = target_directory_path;
binary_path.push(format!(
"{}.{}",
zinc_const::file_name::BINARY,
zinc_const::extension::BINARY
));
TargetDependenciesDirectory::create(&manifest_path)?;
if let Some(dependencies) = manifest.dependencies {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let mut downloader = Downloader::new(&http_client, &manifest_path);
downloader.download_dependency_list(dependencies).await?;
}
Compiler::build_release(
self.verbosity,
self.quiet,
manifest.project.name.as_str(),
&manifest.project.version,
&manifest_path,
false,
)?;
let bytecode = BytecodeFile::try_from_path(&binary_path, true)?;
let input = InputFile::try_from_path(&input_path)?;
let arguments = input
.inner
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get("arguments")
.cloned()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get(zinc_const::contract::CONSTRUCTOR_IDENTIFIER)
.cloned()
.ok_or_else(|| {
Error::MissingInputSection(zinc_const::contract::CONSTRUCTOR_IDENTIFIER.to_owned())
})?;
if !verifying_key_path.exists() {
VirtualMachine::setup_contract(
self.verbosity,
self.quiet,
&binary_path,
zinc_const::contract::CONSTRUCTOR_IDENTIFIER,
&proving_key_path,
&verifying_key_path,
)?;
}
let verifying_key = VerifyingKeyFile::try_from(&verifying_key_path)?;
if !self.quiet {
eprintln!(
" {} the instance `{}` of `{} v{}` to network `{}`",
"Uploading".bright_green(),
self.instance,
manifest.project.name,
manifest.project.version,
network,
);
}
let response = http_client
.publish(
zinc_types::PublishRequestQuery::new(
manifest.project.name,
manifest.project.version,
self.instance,
self.change_pubkey_fee_token.clone(),
),
zinc_types::PublishRequestBody::new(
project,
bytecode.inner,
arguments,
verifying_key.inner,
),
)
.await?;
if !self.quiet {
eprintln!(
" {} {}",
"Address".bright_green(),
serde_json::to_string(&response.address)
.expect(zinc_const::panic::DATA_CONVERSION)
.replace("\"", "")
);
}
let private_key = PrivateKeyFile::try_from(&manifest_path)?;
let signer_private_key: H256 = private_key.inner.parse()?;
let signer_address = PackedEthSignature::address_from_private_key(&signer_private_key)?;
let wallet_credentials = zksync::WalletCredentials::from_eth_signer(
signer_address,
PrivateKeySigner::new(signer_private_key),
network.into(),
)
.await
.expect(zinc_const::panic::DATA_CONVERSION);
let wallet =
zksync::Wallet::new(zksync::RpcProvider::new(network.into()), wallet_credentials)
.await?;
let initial_transfer = crate::transaction::new_initial(
&wallet,
response.address,
self.change_pubkey_fee_token,
response.change_pubkey_fee,
)
.await?;
let address = response.address;
let response = http_client
.initialize(
zinc_types::InitializeRequestQuery::new(response.address),
zinc_types::InitializeRequestBody::new(initial_transfer),
)
.await?;
if !self.quiet {
eprintln!(" {} {}", "Account ID | {
Self {
address,
account_id,
}
} | identifier_body |
publish.rs | ` subcommand.
//!
use std::convert::TryFrom;
use std::path::PathBuf;
use std::str::FromStr;
use colored::Colorize;
use structopt::StructOpt;
use zksync::web3::types::H256;
use zksync_eth_signer::PrivateKeySigner;
use zksync_types::tx::PackedEthSignature;
use crate::error::Error;
use crate::executable::compiler::Compiler;
use crate::executable::virtual_machine::VirtualMachine;
use crate::http::downloader::Downloader;
use crate::http::Client as HttpClient;
use crate::network::Network;
use crate::project::data::input::Input as InputFile;
use crate::project::data::private_key::PrivateKey as PrivateKeyFile;
use crate::project::data::verifying_key::VerifyingKey as VerifyingKeyFile;
use crate::project::data::Directory as DataDirectory;
use crate::project::src::Directory as SourceDirectory;
use crate::project::target::bytecode::Bytecode as BytecodeFile;
use crate::project::target::deps::Directory as TargetDependenciesDirectory;
use crate::project::target::Directory as TargetDirectory;
///
/// The Zargo package manager `publish` subcommand.
///
#[derive(Debug, StructOpt)]
#[structopt(about = "Uploads the smart contract to the specified network")]
pub struct Command {
/// Prints more logs, if passed several times.
#[structopt(short = "v", long = "verbose", parse(from_occurrences))]
pub verbosity: usize,
/// Suppresses output, if set.
#[structopt(short = "q", long = "quiet")]
pub quiet: bool,
/// The path to the Zinc project manifest file.
#[structopt(
long = "manifest-path",
parse(from_os_str),
default_value = "./Zargo.toml"
)]
pub manifest_path: PathBuf,
/// Sets the contract instance name.
#[structopt(long = "instance")]
pub instance: String,
/// Sets the network name, where the contract must be published to.
#[structopt(long = "network", default_value = "localhost")]
pub network: String,
/// Sets the change-pubkey fee token.
#[structopt(long = "change-pubkey-fee-token", default_value = "ETH")]
pub change_pubkey_fee_token: String,
}
///
/// The publish data. Used for testing purposes.
///
pub struct | {
/// The address of the published contract instance.
pub address: zksync_types::Address,
/// The account ID of the published contract instance.
pub account_id: zksync_types::AccountId,
}
impl Data {
///
/// A shortcut constructor.
///
pub fn new(address: zksync_types::Address, account_id: zksync_types::AccountId) -> Self {
Self {
address,
account_id,
}
}
}
impl Command {
///
/// A shortcut constructor.
///
pub fn new(
verbosity: usize,
quiet: bool,
manifest_path: PathBuf,
instance: String,
network: Option<String>,
change_pubkey_fee_token: Option<String>,
) -> Self {
Self {
verbosity,
quiet,
manifest_path,
instance,
network: network
.unwrap_or_else(|| Network::from(zksync::Network::Localhost).to_string()),
change_pubkey_fee_token: change_pubkey_fee_token.unwrap_or_else(|| "ETH".to_owned()),
}
}
///
/// Executes the command.
///
pub async fn execute(self) -> anyhow::Result<Data> {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let manifest = zinc_project::Manifest::try_from(&self.manifest_path)?;
match manifest.project.r#type {
zinc_project::ProjectType::Contract => {}
_ => anyhow::bail!(Error::NotAContract),
}
let mut manifest_path = self.manifest_path;
if manifest_path.is_file() {
manifest_path.pop();
}
if let zinc_project::ProjectType::Contract = manifest.project.r#type {
if !PrivateKeyFile::exists_at(&manifest_path) {
PrivateKeyFile::default().write_to(&manifest_path)?;
}
}
let source_directory_path = SourceDirectory::path(&manifest_path);
let source =
zinc_project::Source::try_from_path(&source_directory_path, &manifest_path, true)?;
let project = zinc_project::Project::new(manifest.clone(), source);
DataDirectory::create(&manifest_path)?;
let data_directory_path = DataDirectory::path(&manifest_path);
let mut input_path = data_directory_path.clone();
input_path.push(format!(
"{}.{}",
zinc_const::file_name::INPUT,
zinc_const::extension::JSON,
));
let mut proving_key_path = data_directory_path.clone();
proving_key_path.push(zinc_const::file_name::PROVING_KEY);
let mut verifying_key_path = data_directory_path.clone();
verifying_key_path.push(zinc_const::file_name::VERIFYING_KEY.to_owned());
TargetDirectory::create(&manifest_path, true)?;
let target_directory_path = TargetDirectory::path(&manifest_path, true);
let mut binary_path = target_directory_path;
binary_path.push(format!(
"{}.{}",
zinc_const::file_name::BINARY,
zinc_const::extension::BINARY
));
TargetDependenciesDirectory::create(&manifest_path)?;
if let Some(dependencies) = manifest.dependencies {
let network = zksync::Network::from_str(self.network.as_str())
.map(Network::from)
.map_err(Error::NetworkInvalid)?;
let url = network
.try_into_url()
.map_err(Error::NetworkUnimplemented)?;
let http_client = HttpClient::new(url);
let mut downloader = Downloader::new(&http_client, &manifest_path);
downloader.download_dependency_list(dependencies).await?;
}
Compiler::build_release(
self.verbosity,
self.quiet,
manifest.project.name.as_str(),
&manifest.project.version,
&manifest_path,
false,
)?;
let bytecode = BytecodeFile::try_from_path(&binary_path, true)?;
let input = InputFile::try_from_path(&input_path)?;
let arguments = input
.inner
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get("arguments")
.cloned()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.as_object()
.ok_or_else(|| Error::MissingInputSection("arguments".to_owned()))?
.get(zinc_const::contract::CONSTRUCTOR_IDENTIFIER)
.cloned()
.ok_or_else(|| {
Error::MissingInputSection(zinc_const::contract::CONSTRUCTOR_IDENTIFIER.to_owned())
})?;
if !verifying_key_path.exists() {
VirtualMachine::setup_contract(
self.verbosity,
self.quiet,
&binary_path,
zinc_const::contract::CONSTRUCTOR_IDENTIFIER,
&proving_key_path,
&verifying_key_path,
)?;
}
let verifying_key = VerifyingKeyFile::try_from(&verifying_key_path)?;
if !self.quiet {
eprintln!(
" {} the instance `{}` of `{} v{}` to network `{}`",
"Uploading".bright_green(),
self.instance,
manifest.project.name,
manifest.project.version,
network,
);
}
let response = http_client
.publish(
zinc_types::PublishRequestQuery::new(
manifest.project.name,
manifest.project.version,
self.instance,
self.change_pubkey_fee_token.clone(),
),
zinc_types::PublishRequestBody::new(
project,
bytecode.inner,
arguments,
verifying_key.inner,
),
)
.await?;
if !self.quiet {
eprintln!(
" {} {}",
"Address".bright_green(),
serde_json::to_string(&response.address)
.expect(zinc_const::panic::DATA_CONVERSION)
.replace("\"", "")
);
}
let private_key = PrivateKeyFile::try_from(&manifest_path)?;
let signer_private_key: H256 = private_key.inner.parse()?;
let signer_address = PackedEthSignature::address_from_private_key(&signer_private_key)?;
let wallet_credentials = zksync::WalletCredentials::from_eth_signer(
signer_address,
PrivateKeySigner::new(signer_private_key),
network.into(),
)
.await
.expect(zinc_const::panic::DATA_CONVERSION);
let wallet =
zksync::Wallet::new(zksync::RpcProvider::new(network.into()), wallet_credentials)
.await?;
let initial_transfer = crate::transaction::new_initial(
&wallet,
response.address,
self.change_pubkey_fee_token,
response.change_pubkey_fee,
)
.await?;
let address = response.address;
let response = http_client
.initialize(
zinc_types::InitializeRequestQuery::new(response.address),
zinc_types::InitializeRequestBody::new(initial_transfer),
)
.await?;
if !self.quiet {
eprintln!(" {} {}", "Account ID | Data | identifier_name |
process_release_data.py | fields = [fileindex_item[COLUMN_CHECKSUM], fileindex_item[COLUMN_FILENAME]]
if len(fileindex_item) > COLUMN_FILEDATE:
fields.append(fileindex_item[COLUMN_FILEDATE])
f.write(bytes(";".join(fields) + "\n", "UTF-8"))
def write_fileindex_md(hashalgo_md, fileindex, repo_name, hashalgo, format=None, include_local_filename=False):
"""Write file index as markdown.
format: list or table
"""
if format is None:
format = "list"
with open(hashalgo_md, "wb") as f:
if format=="table":
header = []
header.append("| FileName | FileDate | " + hashalgo + " |\n")
header.append("|----------|----------|-------------|\n")
if include_local_filename:
header[0] = "| LocalFileName " + header[0]
header[1] = "|---------------" + header[1]
for header_line in header:
f.write(bytes(header_line, "UTF-8"))
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
local_filename = fileindex_item[COLUMN_LOCAL_FILENAME] if len(fileindex_item) > COLUMN_LOCAL_FILENAME else ""
if format=="table":
row = ""
if include_local_filename:
row += "| " + local_filename + " "
row += "| [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ") "
row += "| " + filedate + " "
row += "| " + checksum + " "
f.write(bytes(row + "|\n", "UTF-8",))
else:
f.write(bytes("- [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ")\n", "UTF-8",))
if include_local_filename:
f.write(bytes(" - LocalFileName: " + local_filename + "\n", "UTF-8",))
if filedate:
f.write(bytes(" - FileDate: " + filedate + "\n", "UTF-8",))
f.write(bytes(" - " + hashalgo +": " + checksum + "\n", "UTF-8",))
def get_filedate(filepath):
# Return
import datetime
return datetime.datetime.utcfromtimestamp(os.path.getmtime(filepath)).replace(tzinfo=datetime.timezone.utc)
def set_filedate(filepath, filedate):
stat = os.stat(filepath)
atime = stat.st_atime
os.utime(filepath, (atime, filedate.timestamp()))
def date_to_utc_string(filedate):
"""Convert date object to string in UTC time zone"""
return filedate.isoformat()
def date_from_utc_string(filedate_utc_string):
"""Convert string in UTC time zone to date object"""
# We only accept date in UTC (indicated by +00:00 or Z suffix)
import datetime
try:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%f+00:00").replace(tzinfo=datetime.timezone.utc)
except ValueError:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=datetime.timezone.utc)
return date_object
def download(repo_name, root_dir, download_dir, hashalgo, github_token=None):
"""Download files associated with HASHALGO release into directory (root_dir)/(hashalgo).
List of files is taken from (root_dir)/(hashalgo).csv. If multiple hashes associated with
the same filename then the last entry will be used.
"""
if github_token:
github_release._github_token_cli_arg = github_token
if not os.path.isdir(download_dir):
os.mkdir(download_dir)
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
logging.debug(hashalgo + ": downloading release assets")
# Find out which filenames are present in multiple versions (need to give them unique names)
filenames = [checksum_filename[1] for checksum_filename in fileindex]
from collections import Counter
# Sort based on filename and filedate
fileindex.sort(key=lambda a: (a[COLUMN_FILENAME].casefold(), a[COLUMN_FILEDATE]))
filenames_counter = Counter(filenames)
# download saves files to current working directory, so we need to temporarily
# change working dir to hashalgo_dir folder
with cd(hashalgo_dir):
fileindex_with_local_filename = []
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
filepath = os.path.join(hashalgo_dir, checksum)
if not os.path.isfile(filepath):
if not github_release.gh_asset_download(repo_name, hashalgo, checksum):
logging.error(
hashalgo
+ ": failed to download "
+ filename
+ " ("
+ checksum
+ ")"
)
continue
logging.debug(
hashalgo + ": downloaded " + filename + " (" + checksum + ")"
)
# determine local filename
if filenames_counter[filename] == 1:
# unique filename
local_filename = filename
else:
# multiple versions of the filename with different content
# add checksum as suffix to distinguish them
local_filename = filename + "." + checksum
local_filepath = os.path.join(download_dir, local_filename)
# set file name and date from index
copyfile(filepath, local_filepath)
set_filedate(local_filepath, date_from_utc_string(filedate if filedate else DEFAULT_FILE_DATE_UTC_STRING))
# save local fileindex
fileindex_with_local_filename.append([checksum, filename, filedate, local_filename])
# Create new hashalgo.csv from existing and incoming files
write_fileindex_csv(hashalgo_csv, fileindex)
hashalgo_local_md = os.path.join(download_dir, hashalgo + "_local.md")
write_fileindex_md(hashalgo_local_md, fileindex_with_local_filename, repo_name, hashalgo, include_local_filename=True)
def upload(repo_name, root_dir, incoming_dir, hashalgo, github_token=None):
"""Upload incoming files associated them with hashalgo release."""
if github_token:
github_release._github_token_cli_arg = github_token
hashcmd = get_hashcmd(hashalgo)
if not hashcmd:
raise ValueError('hashalgo "' + hashalgo + '" not found')
if not os.path.isdir(incoming_dir):
raise ValueError("Missing " + incoming_dir + " directory")
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
# Download information about current release
# Get current fileindex
try:
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
except ValueError:
# New release
hashalgo_csv = os.path.join(hashalgo_dir, hashalgo + ".csv")
fileindex = []
# Get list of successfully uploaded assets (to avoid uploading them again)
# and delete partially uploaded ones.
uploaded_assets = (
github_release.get_assets(repo_name, hashalgo) if fileindex else []
)
uploaded_hashes = []
for asset in uploaded_assets:
if asset["state"] == "uploaded":
uploaded_hashes.append(asset["name"])
else:
# Remove asset partially uploaded
github_release.gh_asset_delete(repo_name, hashalgo, asset["name"])
# Update release information with incoming data
# Add incoming files to fileindex and hashalgo_dir
filenames = [
f
for f in os.listdir(incoming_dir)
if os.path.isfile(os.path.join(incoming_dir, f)) and not f.startswith(".")
]
for filename in filenames:
filepath = os.path.join(incoming_dir, filename)
checksum = hashcmd(filepath)
filedate = date_to_utc_string(get_filedate(filepath))
existingItems = [fileindex_item for fileindex_item in fileindex
if fileindex_item[COLUMN_CHECKSUM] == checksum and fileindex_item[COLUMN_FILENAME] == filename]
if not existingItems:
# new item
fileindex.append([checksum, filename, filedate])
# Make sure the hash-named file is present
hashfilepath = os.path.join(hashalgo_dir, checksum)
if not os.path.isfile(hashfilepath):
copyfile(filepath, hashfilepath)
# Create new hashalgo.csv from existing and incoming files | fileindex.sort(key=lambda a: (a[COLUMN_FILENAME].casefold(), a[COLUMN_FILEDATE]))
write_fileindex_csv(hashalgo_csv, fileindex)
hashalgo_md = os.path.join(root_dir, hashalgo_dir, hashalgo + ".md")
write_fileindex_md(hashalgo_md, fileindex, repo_name, hashalgo)
| random_line_split | |
process_release_data.py | :
"""Context manager for changing the current working directory"""
def __init__(self, newPath):
self.newPath = os.path.expanduser(newPath)
def __enter__(self):
self.savedPath = os.getcwd()
os.chdir(self.newPath)
def __exit__(self, etype, value, traceback):
os.chdir(self.savedPath)
def download_fileindex_csv(repo_name, download_dir, hashalgo, github_token=None):
if github_token:
github_release._github_token_cli_arg = github_token
fileindex_csv = os.path.join(download_dir, hashalgo + ".csv")
if os.path.isfile(fileindex_csv):
os.remove(fileindex_csv)
with cd(download_dir):
if not github_release.gh_asset_download(repo_name, hashalgo, hashalgo + ".csv"):
raise ValueError("Failed to download " + hashalgo + ".csv")
return fileindex_csv
def read_fileindex_csv(hashalgo_csv):
fileindex = []
with open(hashalgo_csv, "r") as f:
for line in f:
fields = line.rstrip().split(";")
if len(fields) <= COLUMN_FILEDATE:
fields.append("") # if date is missing then add an empty field
fileindex.append(fields)
return fileindex
def write_fileindex_csv(hashalgo_csv, fileindex):
with open(hashalgo_csv, "wb") as f:
for fileindex_item in fileindex:
fields = [fileindex_item[COLUMN_CHECKSUM], fileindex_item[COLUMN_FILENAME]]
if len(fileindex_item) > COLUMN_FILEDATE:
fields.append(fileindex_item[COLUMN_FILEDATE])
f.write(bytes(";".join(fields) + "\n", "UTF-8"))
def write_fileindex_md(hashalgo_md, fileindex, repo_name, hashalgo, format=None, include_local_filename=False):
"""Write file index as markdown.
format: list or table
"""
if format is None:
format = "list"
with open(hashalgo_md, "wb") as f:
if format=="table":
header = []
header.append("| FileName | FileDate | " + hashalgo + " |\n")
header.append("|----------|----------|-------------|\n")
if include_local_filename:
header[0] = "| LocalFileName " + header[0]
header[1] = "|---------------" + header[1]
for header_line in header:
f.write(bytes(header_line, "UTF-8"))
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
local_filename = fileindex_item[COLUMN_LOCAL_FILENAME] if len(fileindex_item) > COLUMN_LOCAL_FILENAME else ""
if format=="table":
row = ""
if include_local_filename:
row += "| " + local_filename + " "
row += "| [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ") "
row += "| " + filedate + " "
row += "| " + checksum + " "
f.write(bytes(row + "|\n", "UTF-8",))
else:
f.write(bytes("- [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ")\n", "UTF-8",))
if include_local_filename:
f.write(bytes(" - LocalFileName: " + local_filename + "\n", "UTF-8",))
if filedate:
f.write(bytes(" - FileDate: " + filedate + "\n", "UTF-8",))
f.write(bytes(" - " + hashalgo +": " + checksum + "\n", "UTF-8",))
def get_filedate(filepath):
# Return
import datetime
return datetime.datetime.utcfromtimestamp(os.path.getmtime(filepath)).replace(tzinfo=datetime.timezone.utc)
def set_filedate(filepath, filedate):
stat = os.stat(filepath)
atime = stat.st_atime
os.utime(filepath, (atime, filedate.timestamp()))
def date_to_utc_string(filedate):
"""Convert date object to string in UTC time zone"""
return filedate.isoformat()
def date_from_utc_string(filedate_utc_string):
"""Convert string in UTC time zone to date object"""
# We only accept date in UTC (indicated by +00:00 or Z suffix)
import datetime
try:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%f+00:00").replace(tzinfo=datetime.timezone.utc)
except ValueError:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=datetime.timezone.utc)
return date_object
def download(repo_name, root_dir, download_dir, hashalgo, github_token=None):
"""Download files associated with HASHALGO release into directory (root_dir)/(hashalgo).
List of files is taken from (root_dir)/(hashalgo).csv. If multiple hashes associated with
the same filename then the last entry will be used.
"""
if github_token:
github_release._github_token_cli_arg = github_token
if not os.path.isdir(download_dir):
os.mkdir(download_dir)
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
logging.debug(hashalgo + ": downloading release assets")
# Find out which filenames are present in multiple versions (need to give them unique names)
filenames = [checksum_filename[1] for checksum_filename in fileindex]
from collections import Counter
# Sort based on filename and filedate
fileindex.sort(key=lambda a: (a[COLUMN_FILENAME].casefold(), a[COLUMN_FILEDATE]))
filenames_counter = Counter(filenames)
# download saves files to current working directory, so we need to temporarily
# change working dir to hashalgo_dir folder
with cd(hashalgo_dir):
fileindex_with_local_filename = []
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
filepath = os.path.join(hashalgo_dir, checksum)
if not os.path.isfile(filepath):
if not github_release.gh_asset_download(repo_name, hashalgo, checksum):
logging.error(
hashalgo
+ ": failed to download "
+ filename
+ " ("
+ checksum
+ ")"
)
continue
logging.debug(
hashalgo + ": downloaded " + filename + " (" + checksum + ")"
)
# determine local filename
if filenames_counter[filename] == 1:
# unique filename
local_filename = filename
else:
# multiple versions of the filename with different content
# add checksum as suffix to distinguish them
local_filename = filename + "." + checksum
local_filepath = os.path.join(download_dir, local_filename)
# set file name and date from index
copyfile(filepath, local_filepath)
set_filedate(local_filepath, date_from_utc_string(filedate if filedate else DEFAULT_FILE_DATE_UTC_STRING))
# save local fileindex
fileindex_with_local_filename.append([checksum, filename, filedate, local_filename])
# Create new hashalgo.csv from existing and incoming files
write_fileindex_csv(hashalgo_csv, fileindex)
hashalgo_local_md = os.path.join(download_dir, hashalgo + "_local.md")
write_fileindex_md(hashalgo_local_md, fileindex_with_local_filename, repo_name, hashalgo, include_local_filename=True)
def upload(repo_name, root_dir, incoming_dir, hashalgo, github_token=None):
"""Upload incoming files associated them with hashalgo release."""
if github_token:
github_release._github_token_cli_arg = github_token
hashcmd = get_hashcmd(hashalgo)
if not hashcmd:
raise ValueError('hashalgo "' + hashalgo + '" not found')
if not os.path.isdir(incoming_dir):
raise ValueError("Missing " + incoming_dir + " directory")
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
# Download information about current release
# Get current fileindex
try:
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
except ValueError:
# New release
hashalgo_csv = os.path.join(hashalgo_dir, hashalgo + ".csv")
fileindex = []
# Get list of successfully uploaded assets (to avoid uploading them again)
# and delete partially uploaded ones.
uploaded_assets = (
github_release.get_assets(repo_name, hashalgo) if fileindex else []
)
uploaded_hashes = []
for asset in uploaded_assets:
if asset["state"] == "uploaded":
uploaded_hashes.append(asset["name"])
else:
# Remove asset partially uploaded | cd | identifier_name | |
process_release_data.py | .savedPath = os.getcwd()
os.chdir(self.newPath)
def __exit__(self, etype, value, traceback):
os.chdir(self.savedPath)
def download_fileindex_csv(repo_name, download_dir, hashalgo, github_token=None):
if github_token:
github_release._github_token_cli_arg = github_token
fileindex_csv = os.path.join(download_dir, hashalgo + ".csv")
if os.path.isfile(fileindex_csv):
os.remove(fileindex_csv)
with cd(download_dir):
if not github_release.gh_asset_download(repo_name, hashalgo, hashalgo + ".csv"):
raise ValueError("Failed to download " + hashalgo + ".csv")
return fileindex_csv
def read_fileindex_csv(hashalgo_csv):
fileindex = []
with open(hashalgo_csv, "r") as f:
for line in f:
fields = line.rstrip().split(";")
if len(fields) <= COLUMN_FILEDATE:
fields.append("") # if date is missing then add an empty field
fileindex.append(fields)
return fileindex
def write_fileindex_csv(hashalgo_csv, fileindex):
with open(hashalgo_csv, "wb") as f:
for fileindex_item in fileindex:
fields = [fileindex_item[COLUMN_CHECKSUM], fileindex_item[COLUMN_FILENAME]]
if len(fileindex_item) > COLUMN_FILEDATE:
fields.append(fileindex_item[COLUMN_FILEDATE])
f.write(bytes(";".join(fields) + "\n", "UTF-8"))
def write_fileindex_md(hashalgo_md, fileindex, repo_name, hashalgo, format=None, include_local_filename=False):
"""Write file index as markdown.
format: list or table
"""
if format is None:
format = "list"
with open(hashalgo_md, "wb") as f:
if format=="table":
header = []
header.append("| FileName | FileDate | " + hashalgo + " |\n")
header.append("|----------|----------|-------------|\n")
if include_local_filename:
header[0] = "| LocalFileName " + header[0]
header[1] = "|---------------" + header[1]
for header_line in header:
f.write(bytes(header_line, "UTF-8"))
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
local_filename = fileindex_item[COLUMN_LOCAL_FILENAME] if len(fileindex_item) > COLUMN_LOCAL_FILENAME else ""
if format=="table":
row = ""
if include_local_filename:
row += "| " + local_filename + " "
row += "| [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ") "
row += "| " + filedate + " "
row += "| " + checksum + " "
f.write(bytes(row + "|\n", "UTF-8",))
else:
f.write(bytes("- [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ")\n", "UTF-8",))
if include_local_filename:
f.write(bytes(" - LocalFileName: " + local_filename + "\n", "UTF-8",))
if filedate:
f.write(bytes(" - FileDate: " + filedate + "\n", "UTF-8",))
f.write(bytes(" - " + hashalgo +": " + checksum + "\n", "UTF-8",))
def get_filedate(filepath):
# Return
import datetime
return datetime.datetime.utcfromtimestamp(os.path.getmtime(filepath)).replace(tzinfo=datetime.timezone.utc)
def set_filedate(filepath, filedate):
stat = os.stat(filepath)
atime = stat.st_atime
os.utime(filepath, (atime, filedate.timestamp()))
def date_to_utc_string(filedate):
"""Convert date object to string in UTC time zone"""
return filedate.isoformat()
def date_from_utc_string(filedate_utc_string):
"""Convert string in UTC time zone to date object"""
# We only accept date in UTC (indicated by +00:00 or Z suffix)
import datetime
try:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%f+00:00").replace(tzinfo=datetime.timezone.utc)
except ValueError:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=datetime.timezone.utc)
return date_object
def download(repo_name, root_dir, download_dir, hashalgo, github_token=None):
| logging.debug(hashalgo + ": downloading release assets")
# Find out which filenames are present in multiple versions (need to give them unique names)
filenames = [checksum_filename[1] for checksum_filename in fileindex]
from collections import Counter
# Sort based on filename and filedate
fileindex.sort(key=lambda a: (a[COLUMN_FILENAME].casefold(), a[COLUMN_FILEDATE]))
filenames_counter = Counter(filenames)
# download saves files to current working directory, so we need to temporarily
# change working dir to hashalgo_dir folder
with cd(hashalgo_dir):
fileindex_with_local_filename = []
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
filepath = os.path.join(hashalgo_dir, checksum)
if not os.path.isfile(filepath):
if not github_release.gh_asset_download(repo_name, hashalgo, checksum):
logging.error(
hashalgo
+ ": failed to download "
+ filename
+ " ("
+ checksum
+ ")"
)
continue
logging.debug(
hashalgo + ": downloaded " + filename + " (" + checksum + ")"
)
# determine local filename
if filenames_counter[filename] == 1:
# unique filename
local_filename = filename
else:
# multiple versions of the filename with different content
# add checksum as suffix to distinguish them
local_filename = filename + "." + checksum
local_filepath = os.path.join(download_dir, local_filename)
# set file name and date from index
copyfile(filepath, local_filepath)
set_filedate(local_filepath, date_from_utc_string(filedate if filedate else DEFAULT_FILE_DATE_UTC_STRING))
# save local fileindex
fileindex_with_local_filename.append([checksum, filename, filedate, local_filename])
# Create new hashalgo.csv from existing and incoming files
write_fileindex_csv(hashalgo_csv, fileindex)
hashalgo_local_md = os.path.join(download_dir, hashalgo + "_local.md")
write_fileindex_md(hashalgo_local_md, fileindex_with_local_filename, repo_name, hashalgo, include_local_filename=True)
def upload(repo_name, root_dir, incoming_dir, hashalgo, github_token=None):
"""Upload incoming files associated them with hashalgo release."""
if github_token:
github_release._github_token_cli_arg = github_token
hashcmd = get_hashcmd(hashalgo)
if not hashcmd:
raise ValueError('hashalgo "' + hashalgo + '" not found')
if not os.path.isdir(incoming_dir):
raise ValueError("Missing " + incoming_dir + " directory")
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
# Download information about current release
# Get current fileindex
try:
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
except ValueError:
# New release
hashalgo_csv = os.path.join(hashalgo_dir, hashalgo + ".csv")
fileindex = []
# Get list of successfully uploaded assets (to avoid uploading them again)
# and delete partially uploaded ones.
uploaded_assets = (
github_release.get_assets(repo_name, hashalgo) if fileindex else []
)
uploaded_hashes = []
for asset in uploaded_assets:
if asset["state"] == "uploaded":
uploaded_hashes.append(asset["name"])
else:
# Remove asset partially uploaded
github_release.gh_asset_delete(repo_name, hashalgo, asset["name"])
# Update release information with incoming data
# Add incoming files to fileindex and hashalgo_dir
filenames = | """Download files associated with HASHALGO release into directory (root_dir)/(hashalgo).
List of files is taken from (root_dir)/(hashalgo).csv. If multiple hashes associated with
the same filename then the last entry will be used.
"""
if github_token:
github_release._github_token_cli_arg = github_token
if not os.path.isdir(download_dir):
os.mkdir(download_dir)
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
| identifier_body |
process_release_data.py | .savedPath = os.getcwd()
os.chdir(self.newPath)
def __exit__(self, etype, value, traceback):
os.chdir(self.savedPath)
def download_fileindex_csv(repo_name, download_dir, hashalgo, github_token=None):
if github_token:
github_release._github_token_cli_arg = github_token
fileindex_csv = os.path.join(download_dir, hashalgo + ".csv")
if os.path.isfile(fileindex_csv):
os.remove(fileindex_csv)
with cd(download_dir):
if not github_release.gh_asset_download(repo_name, hashalgo, hashalgo + ".csv"):
raise ValueError("Failed to download " + hashalgo + ".csv")
return fileindex_csv
def read_fileindex_csv(hashalgo_csv):
fileindex = []
with open(hashalgo_csv, "r") as f:
for line in f:
|
return fileindex
def write_fileindex_csv(hashalgo_csv, fileindex):
with open(hashalgo_csv, "wb") as f:
for fileindex_item in fileindex:
fields = [fileindex_item[COLUMN_CHECKSUM], fileindex_item[COLUMN_FILENAME]]
if len(fileindex_item) > COLUMN_FILEDATE:
fields.append(fileindex_item[COLUMN_FILEDATE])
f.write(bytes(";".join(fields) + "\n", "UTF-8"))
def write_fileindex_md(hashalgo_md, fileindex, repo_name, hashalgo, format=None, include_local_filename=False):
"""Write file index as markdown.
format: list or table
"""
if format is None:
format = "list"
with open(hashalgo_md, "wb") as f:
if format=="table":
header = []
header.append("| FileName | FileDate | " + hashalgo + " |\n")
header.append("|----------|----------|-------------|\n")
if include_local_filename:
header[0] = "| LocalFileName " + header[0]
header[1] = "|---------------" + header[1]
for header_line in header:
f.write(bytes(header_line, "UTF-8"))
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
local_filename = fileindex_item[COLUMN_LOCAL_FILENAME] if len(fileindex_item) > COLUMN_LOCAL_FILENAME else ""
if format=="table":
row = ""
if include_local_filename:
row += "| " + local_filename + " "
row += "| [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ") "
row += "| " + filedate + " "
row += "| " + checksum + " "
f.write(bytes(row + "|\n", "UTF-8",))
else:
f.write(bytes("- [" + filename + "](https://github.com/" + repo_name + "/releases/download/" + hashalgo + "/" + checksum + ")\n", "UTF-8",))
if include_local_filename:
f.write(bytes(" - LocalFileName: " + local_filename + "\n", "UTF-8",))
if filedate:
f.write(bytes(" - FileDate: " + filedate + "\n", "UTF-8",))
f.write(bytes(" - " + hashalgo +": " + checksum + "\n", "UTF-8",))
def get_filedate(filepath):
# Return
import datetime
return datetime.datetime.utcfromtimestamp(os.path.getmtime(filepath)).replace(tzinfo=datetime.timezone.utc)
def set_filedate(filepath, filedate):
stat = os.stat(filepath)
atime = stat.st_atime
os.utime(filepath, (atime, filedate.timestamp()))
def date_to_utc_string(filedate):
"""Convert date object to string in UTC time zone"""
return filedate.isoformat()
def date_from_utc_string(filedate_utc_string):
"""Convert string in UTC time zone to date object"""
# We only accept date in UTC (indicated by +00:00 or Z suffix)
import datetime
try:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%f+00:00").replace(tzinfo=datetime.timezone.utc)
except ValueError:
date_object = datetime.datetime.strptime(filedate_utc_string, "%Y-%m-%dT%H:%M:%S.%fZ").replace(tzinfo=datetime.timezone.utc)
return date_object
def download(repo_name, root_dir, download_dir, hashalgo, github_token=None):
"""Download files associated with HASHALGO release into directory (root_dir)/(hashalgo).
List of files is taken from (root_dir)/(hashalgo).csv. If multiple hashes associated with
the same filename then the last entry will be used.
"""
if github_token:
github_release._github_token_cli_arg = github_token
if not os.path.isdir(download_dir):
os.mkdir(download_dir)
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
logging.debug(hashalgo + ": downloading release assets")
# Find out which filenames are present in multiple versions (need to give them unique names)
filenames = [checksum_filename[1] for checksum_filename in fileindex]
from collections import Counter
# Sort based on filename and filedate
fileindex.sort(key=lambda a: (a[COLUMN_FILENAME].casefold(), a[COLUMN_FILEDATE]))
filenames_counter = Counter(filenames)
# download saves files to current working directory, so we need to temporarily
# change working dir to hashalgo_dir folder
with cd(hashalgo_dir):
fileindex_with_local_filename = []
for fileindex_item in fileindex:
checksum = fileindex_item[COLUMN_CHECKSUM]
filename = fileindex_item[COLUMN_FILENAME]
filedate = fileindex_item[COLUMN_FILEDATE] if len(fileindex_item) > COLUMN_FILEDATE else ""
filepath = os.path.join(hashalgo_dir, checksum)
if not os.path.isfile(filepath):
if not github_release.gh_asset_download(repo_name, hashalgo, checksum):
logging.error(
hashalgo
+ ": failed to download "
+ filename
+ " ("
+ checksum
+ ")"
)
continue
logging.debug(
hashalgo + ": downloaded " + filename + " (" + checksum + ")"
)
# determine local filename
if filenames_counter[filename] == 1:
# unique filename
local_filename = filename
else:
# multiple versions of the filename with different content
# add checksum as suffix to distinguish them
local_filename = filename + "." + checksum
local_filepath = os.path.join(download_dir, local_filename)
# set file name and date from index
copyfile(filepath, local_filepath)
set_filedate(local_filepath, date_from_utc_string(filedate if filedate else DEFAULT_FILE_DATE_UTC_STRING))
# save local fileindex
fileindex_with_local_filename.append([checksum, filename, filedate, local_filename])
# Create new hashalgo.csv from existing and incoming files
write_fileindex_csv(hashalgo_csv, fileindex)
hashalgo_local_md = os.path.join(download_dir, hashalgo + "_local.md")
write_fileindex_md(hashalgo_local_md, fileindex_with_local_filename, repo_name, hashalgo, include_local_filename=True)
def upload(repo_name, root_dir, incoming_dir, hashalgo, github_token=None):
"""Upload incoming files associated them with hashalgo release."""
if github_token:
github_release._github_token_cli_arg = github_token
hashcmd = get_hashcmd(hashalgo)
if not hashcmd:
raise ValueError('hashalgo "' + hashalgo + '" not found')
if not os.path.isdir(incoming_dir):
raise ValueError("Missing " + incoming_dir + " directory")
hashalgo_dir = os.path.join(root_dir, hashalgo)
if not os.path.isdir(hashalgo_dir):
os.mkdir(hashalgo_dir)
# Download information about current release
# Get current fileindex
try:
hashalgo_csv = download_fileindex_csv(
repo_name, hashalgo_dir, hashalgo, github_token
)
fileindex = read_fileindex_csv(hashalgo_csv)
except ValueError:
# New release
hashalgo_csv = os.path.join(hashalgo_dir, hashalgo + ".csv")
fileindex = []
# Get list of successfully uploaded assets (to avoid uploading them again)
# and delete partially uploaded ones.
uploaded_assets = (
github_release.get_assets(repo_name, hashalgo) if fileindex else []
)
uploaded_hashes = []
for asset in uploaded_assets:
if asset["state"] == "uploaded":
uploaded_hashes.append(asset["name"])
else:
# Remove asset partially uploaded
github_release.gh_asset_delete(repo_name, hashalgo, asset["name"])
# Update release information with incoming data
# Add incoming files to fileindex and hashalgo_dir
filenames | fields = line.rstrip().split(";")
if len(fields) <= COLUMN_FILEDATE:
fields.append("") # if date is missing then add an empty field
fileindex.append(fields) | conditional_block |
model.py | def forward(self, x, pre_sts=None, last_only=False):
"""
:param x: the input sequence
:param pre_sts: to prevent recalculation. the prefix sequence's hidden states and Q,V saved in previous turn.
:return: logits of vocab words
"""
sts = self.transformer(x, pre_sts)
lm_logits = self.lm_head(sts[-1][0], last_only)
return lm_logits, sts
############## components ########################
##################################################
class LMHead(nn.Module):
""" Language Model Head for the transformer """
def __init__(self, model, cfg, n_vocab):
super(LMHead, self).__init__()
self.n_embd = cfg.n_embd
embed_shape = model.embed.weight.shape
self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
self.decoder.weight = model.embed.weight # Tied weights
self.n_decoding_vocab = n_vocab + 2 # and SOS, EOS
def forward(self, h, last_only=False):
if last_only:
h = h[:, -1:, :]
lm_logits = self.decoder(h)
return lm_logits[:, :, :self.n_decoding_vocab]
class TransformerModel(nn.Module):
""" Transformer model """
def __init__(self, cfg, n_indexs, n_ctx):
super(TransformerModel, self).__init__()
self.embed = nn.Embedding(n_indexs, cfg.n_embd)
self.drop = nn.Dropout(cfg.embd_pdrop)
block = Block(n_ctx, cfg, scale=True)
self.h = nn.ModuleList([copy.deepcopy(block) for _ in range(cfg.n_layer)])
nn.init.normal_(self.embed.weight, std=0.02)
def forward(self, x, pre_sts=None):
# for training mode
|
class Block(nn.Module):
def __init__(self, n_ctx, cfg, scale=False):
super(Block, self).__init__()
nx = cfg.n_embd
self.attn = Attention(nx, n_ctx, cfg, scale)
self.ln_1 = LayerNorm(nx)
self.mlp = MLP(4 * nx, cfg)
self.ln_2 = LayerNorm(nx)
def forward(self, x, pre_h=None, pre_key=None, pre_value=None):
l_needed = x.shape[1] if pre_h is None else x.shape[1] - pre_h.shape[1]
x_needed = x[:, -l_needed:, :]
a, key, value = self.attn(x_needed, pre_key, pre_value)
n = self.ln_1(x_needed + a)
m = self.mlp(n)
h = self.ln_2(n + m)
if pre_h is not None:
h = torch.cat([pre_h, h], dim=1)
return h, key, value
class LayerNorm(nn.Module):
"Construct a layernorm module in the OpenAI style (epsilon inside the square root)."
def __init__(self, n_state, e=1e-5):
super(LayerNorm, self).__init__()
self.g = nn.Parameter(torch.ones(n_state))
self.b = nn.Parameter(torch.zeros(n_state))
self.e = e
def forward(self, x):
u = x.mean(-1, keepdim=True)
s = (x - u).pow(2).mean(-1, keepdim=True)
x = (x - u) / torch.sqrt(s + self.e)
return self.g * x + self.b
class Conv1D(nn.Module):
def __init__(self, nf, rf, nx):
super(Conv1D, self).__init__()
self.rf = rf
self.nf = nf
if rf == 1: # faster 1x1 conv
w = torch.empty(nx, nf)
nn.init.normal_(w, std=0.02)
self.w = Parameter(w)
self.b = Parameter(torch.zeros(nf))
else: # was used to train LM
raise NotImplementedError
def forward(self, x):
if self.rf == 1:
size_out = x.size()[:-1] + (self.nf,)
x = torch.addmm(self.b, x.view(-1, x.size(-1)), self.w)
x = x.view(*size_out)
else:
raise NotImplementedError
return x
class Attention(nn.Module):
def __init__(self, nx, n_ctx, cfg, scale=False):
super(Attention, self).__init__()
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert n_state % cfg.n_head == 0
self.register_buffer('b', torch.tril(torch.ones(n_ctx, n_ctx)).view(1, 1, n_ctx, n_ctx))
self.n_head = cfg.n_head
self.split_size = n_state
self.scale = scale
self.c_attn = Conv1D(n_state * 3, 1, nx)
self.c_proj = Conv1D(n_state, 1, nx)
self.attn_dropout = nn.Dropout(cfg.attn_pdrop)
self.resid_dropout = nn.Dropout(cfg.resid_pdrop)
def _attn(self, q, k, v):
w = torch.matmul(q, k)
if self.scale:
w = w / math.sqrt(v.size(-1))
# w = w * self.b + -1e9 * (1 - self.b) # TF implem method: mask_attn_weights
# XD: self.b may be larger than w, so we need to crop it
b = self.b[:, :, (w.size(-1)-w.size(-2)):w.size(-1), :w.size(-1)]
w = w * b + -1e9 * (1 - b)
w = nn.Softmax(dim=-1)(w)
w = self.attn_dropout(w)
return torch.matmul(w, v)
def merge_heads(self, x):
x = x.permute(0, 2, 1, 3).contiguous()
new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)
return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states
def split_heads(self, x, k=False):
new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)
x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states
if k:
return x.permute(0, 2, 3, 1)
else:
return x.permute(0, 2, 1, 3)
def forward(self, x, pre_key=None, pre_value=None):
x = self.c_attn(x)
query, key, value = x.split(self.split_size, dim=2)
query = self.split_heads(query)
key = self.split_heads(key, k=True)
value = self.split_heads(value)
# prevent recalculation
if pre_key is not None and pre_value is not None:
key = torch.cat([pre_key, key], dim=-1)
value = torch.cat([pre_value, value], dim=-2)
a = self._attn(query, key, value)
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a)
return a, key, value
class MLP(nn.Module):
def __init__(self, n_state, cfg): # in MLP: n_state=3072 (4 * n_embd)
super(MLP, self).__init__()
nx = cfg.n_embd
self.c_fc = Conv1D(n_state, 1, nx)
self.c_proj = Conv1D(nx, 1, n_state)
self.act = ACT_FNS[cfg.afn]
self.dropout = nn.Dropout(cfg.resid_pdrop)
def forward(self, x):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
return self.dropout(h2)
############## pretrained model loader ###########
################################################ | if pre_sts is None:
e = self.drop(self.embed(x))
# Add the position information to the input embeddings
h = e.sum(dim=2)
# for eval mode
else:
# get newly added words' embeddings
prev_len = pre_sts[0].size(1)
e_new = self.drop(self.embed(x[:, prev_len:, :]))
h_new = e_new.sum(dim=2)
h = torch.cat([pre_sts[0], h_new], dim=1)
# record the output hidden states of each layer
sts = []
sts.append(h)
for i, block in enumerate(self.h):
# pre_h the prefix sequence's hidden states of the current layer
pre_h, pre_k, pre_v = pre_sts[i+1] if pre_sts is not None else (None, None, None)
h, k, v = block(h, pre_h, pre_k, pre_v)
sts.append((h, k, v))
return sts | identifier_body |
model.py | def forward(self, x, pre_sts=None, last_only=False):
"""
:param x: the input sequence
:param pre_sts: to prevent recalculation. the prefix sequence's hidden states and Q,V saved in previous turn.
:return: logits of vocab words
"""
sts = self.transformer(x, pre_sts)
lm_logits = self.lm_head(sts[-1][0], last_only)
return lm_logits, sts
############## components ########################
##################################################
class LMHead(nn.Module):
""" Language Model Head for the transformer """
def __init__(self, model, cfg, n_vocab):
super(LMHead, self).__init__()
self.n_embd = cfg.n_embd
embed_shape = model.embed.weight.shape
self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
self.decoder.weight = model.embed.weight # Tied weights
self.n_decoding_vocab = n_vocab + 2 # and SOS, EOS
def forward(self, h, last_only=False):
if last_only:
h = h[:, -1:, :]
lm_logits = self.decoder(h)
return lm_logits[:, :, :self.n_decoding_vocab]
class TransformerModel(nn.Module):
""" Transformer model """
def __init__(self, cfg, n_indexs, n_ctx):
super(TransformerModel, self).__init__()
self.embed = nn.Embedding(n_indexs, cfg.n_embd)
self.drop = nn.Dropout(cfg.embd_pdrop)
block = Block(n_ctx, cfg, scale=True)
self.h = nn.ModuleList([copy.deepcopy(block) for _ in range(cfg.n_layer)])
nn.init.normal_(self.embed.weight, std=0.02)
def forward(self, x, pre_sts=None):
# for training mode
if pre_sts is None:
e = self.drop(self.embed(x))
# Add the position information to the input embeddings
h = e.sum(dim=2)
# for eval mode
else:
# get newly added words' embeddings
prev_len = pre_sts[0].size(1)
e_new = self.drop(self.embed(x[:, prev_len:, :]))
h_new = e_new.sum(dim=2)
h = torch.cat([pre_sts[0], h_new], dim=1)
# record the output hidden states of each layer
sts = []
sts.append(h)
for i, block in enumerate(self.h):
# pre_h the prefix sequence's hidden states of the current layer
pre_h, pre_k, pre_v = pre_sts[i+1] if pre_sts is not None else (None, None, None)
h, k, v = block(h, pre_h, pre_k, pre_v)
sts.append((h, k, v))
return sts
class Block(nn.Module):
def __init__(self, n_ctx, cfg, scale=False):
super(Block, self).__init__()
nx = cfg.n_embd
self.attn = Attention(nx, n_ctx, cfg, scale)
self.ln_1 = LayerNorm(nx)
self.mlp = MLP(4 * nx, cfg)
self.ln_2 = LayerNorm(nx)
def forward(self, x, pre_h=None, pre_key=None, pre_value=None):
l_needed = x.shape[1] if pre_h is None else x.shape[1] - pre_h.shape[1]
x_needed = x[:, -l_needed:, :]
a, key, value = self.attn(x_needed, pre_key, pre_value)
n = self.ln_1(x_needed + a)
m = self.mlp(n)
h = self.ln_2(n + m)
if pre_h is not None:
h = torch.cat([pre_h, h], dim=1)
return h, key, value
class LayerNorm(nn.Module):
"Construct a layernorm module in the OpenAI style (epsilon inside the square root)."
def __init__(self, n_state, e=1e-5):
super(LayerNorm, self).__init__()
self.g = nn.Parameter(torch.ones(n_state))
self.b = nn.Parameter(torch.zeros(n_state))
self.e = e
def forward(self, x):
u = x.mean(-1, keepdim=True)
s = (x - u).pow(2).mean(-1, keepdim=True)
x = (x - u) / torch.sqrt(s + self.e)
return self.g * x + self.b
class Conv1D(nn.Module):
def __init__(self, nf, rf, nx):
super(Conv1D, self).__init__()
self.rf = rf
self.nf = nf
if rf == 1: # faster 1x1 conv
w = torch.empty(nx, nf)
nn.init.normal_(w, std=0.02)
self.w = Parameter(w)
self.b = Parameter(torch.zeros(nf))
else: # was used to train LM
raise NotImplementedError
def forward(self, x): | size_out = x.size()[:-1] + (self.nf,)
x = torch.addmm(self.b, x.view(-1, x.size(-1)), self.w)
x = x.view(*size_out)
else:
raise NotImplementedError
return x
class Attention(nn.Module):
def __init__(self, nx, n_ctx, cfg, scale=False):
super(Attention, self).__init__()
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert n_state % cfg.n_head == 0
self.register_buffer('b', torch.tril(torch.ones(n_ctx, n_ctx)).view(1, 1, n_ctx, n_ctx))
self.n_head = cfg.n_head
self.split_size = n_state
self.scale = scale
self.c_attn = Conv1D(n_state * 3, 1, nx)
self.c_proj = Conv1D(n_state, 1, nx)
self.attn_dropout = nn.Dropout(cfg.attn_pdrop)
self.resid_dropout = nn.Dropout(cfg.resid_pdrop)
def _attn(self, q, k, v):
w = torch.matmul(q, k)
if self.scale:
w = w / math.sqrt(v.size(-1))
# w = w * self.b + -1e9 * (1 - self.b) # TF implem method: mask_attn_weights
# XD: self.b may be larger than w, so we need to crop it
b = self.b[:, :, (w.size(-1)-w.size(-2)):w.size(-1), :w.size(-1)]
w = w * b + -1e9 * (1 - b)
w = nn.Softmax(dim=-1)(w)
w = self.attn_dropout(w)
return torch.matmul(w, v)
def merge_heads(self, x):
x = x.permute(0, 2, 1, 3).contiguous()
new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)
return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states
def split_heads(self, x, k=False):
new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)
x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states
if k:
return x.permute(0, 2, 3, 1)
else:
return x.permute(0, 2, 1, 3)
def forward(self, x, pre_key=None, pre_value=None):
x = self.c_attn(x)
query, key, value = x.split(self.split_size, dim=2)
query = self.split_heads(query)
key = self.split_heads(key, k=True)
value = self.split_heads(value)
# prevent recalculation
if pre_key is not None and pre_value is not None:
key = torch.cat([pre_key, key], dim=-1)
value = torch.cat([pre_value, value], dim=-2)
a = self._attn(query, key, value)
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a)
return a, key, value
class MLP(nn.Module):
def __init__(self, n_state, cfg): # in MLP: n_state=3072 (4 * n_embd)
super(MLP, self).__init__()
nx = cfg.n_embd
self.c_fc = Conv1D(n_state, 1, nx)
self.c_proj = Conv1D(nx, 1, n_state)
self.act = ACT_FNS[cfg.afn]
self.dropout = nn.Dropout(cfg.resid_pdrop)
def forward(self, x):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
return self.dropout(h2)
############## pretrained model loader ###########
################################################ | if self.rf == 1: | random_line_split |
model.py | def forward(self, x, pre_sts=None, last_only=False):
"""
:param x: the input sequence
:param pre_sts: to prevent recalculation. the prefix sequence's hidden states and Q,V saved in previous turn.
:return: logits of vocab words
"""
sts = self.transformer(x, pre_sts)
lm_logits = self.lm_head(sts[-1][0], last_only)
return lm_logits, sts
############## components ########################
##################################################
class LMHead(nn.Module):
""" Language Model Head for the transformer """
def __init__(self, model, cfg, n_vocab):
super(LMHead, self).__init__()
self.n_embd = cfg.n_embd
embed_shape = model.embed.weight.shape
self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
self.decoder.weight = model.embed.weight # Tied weights
self.n_decoding_vocab = n_vocab + 2 # and SOS, EOS
def forward(self, h, last_only=False):
if last_only:
h = h[:, -1:, :]
lm_logits = self.decoder(h)
return lm_logits[:, :, :self.n_decoding_vocab]
class TransformerModel(nn.Module):
""" Transformer model """
def __init__(self, cfg, n_indexs, n_ctx):
super(TransformerModel, self).__init__()
self.embed = nn.Embedding(n_indexs, cfg.n_embd)
self.drop = nn.Dropout(cfg.embd_pdrop)
block = Block(n_ctx, cfg, scale=True)
self.h = nn.ModuleList([copy.deepcopy(block) for _ in range(cfg.n_layer)])
nn.init.normal_(self.embed.weight, std=0.02)
def forward(self, x, pre_sts=None):
# for training mode
if pre_sts is None:
e = self.drop(self.embed(x))
# Add the position information to the input embeddings
h = e.sum(dim=2)
# for eval mode
else:
# get newly added words' embeddings
prev_len = pre_sts[0].size(1)
e_new = self.drop(self.embed(x[:, prev_len:, :]))
h_new = e_new.sum(dim=2)
h = torch.cat([pre_sts[0], h_new], dim=1)
# record the output hidden states of each layer
sts = []
sts.append(h)
for i, block in enumerate(self.h):
# pre_h the prefix sequence's hidden states of the current layer
pre_h, pre_k, pre_v = pre_sts[i+1] if pre_sts is not None else (None, None, None)
h, k, v = block(h, pre_h, pre_k, pre_v)
sts.append((h, k, v))
return sts
class Block(nn.Module):
def __init__(self, n_ctx, cfg, scale=False):
super(Block, self).__init__()
nx = cfg.n_embd
self.attn = Attention(nx, n_ctx, cfg, scale)
self.ln_1 = LayerNorm(nx)
self.mlp = MLP(4 * nx, cfg)
self.ln_2 = LayerNorm(nx)
def forward(self, x, pre_h=None, pre_key=None, pre_value=None):
l_needed = x.shape[1] if pre_h is None else x.shape[1] - pre_h.shape[1]
x_needed = x[:, -l_needed:, :]
a, key, value = self.attn(x_needed, pre_key, pre_value)
n = self.ln_1(x_needed + a)
m = self.mlp(n)
h = self.ln_2(n + m)
if pre_h is not None:
h = torch.cat([pre_h, h], dim=1)
return h, key, value
class LayerNorm(nn.Module):
"Construct a layernorm module in the OpenAI style (epsilon inside the square root)."
def __init__(self, n_state, e=1e-5):
super(LayerNorm, self).__init__()
self.g = nn.Parameter(torch.ones(n_state))
self.b = nn.Parameter(torch.zeros(n_state))
self.e = e
def forward(self, x):
u = x.mean(-1, keepdim=True)
s = (x - u).pow(2).mean(-1, keepdim=True)
x = (x - u) / torch.sqrt(s + self.e)
return self.g * x + self.b
class Conv1D(nn.Module):
def __init__(self, nf, rf, nx):
super(Conv1D, self).__init__()
self.rf = rf
self.nf = nf
if rf == 1: # faster 1x1 conv
w = torch.empty(nx, nf)
nn.init.normal_(w, std=0.02)
self.w = Parameter(w)
self.b = Parameter(torch.zeros(nf))
else: # was used to train LM
raise NotImplementedError
def forward(self, x):
if self.rf == 1:
|
else:
raise NotImplementedError
return x
class Attention(nn.Module):
def __init__(self, nx, n_ctx, cfg, scale=False):
super(Attention, self).__init__()
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert n_state % cfg.n_head == 0
self.register_buffer('b', torch.tril(torch.ones(n_ctx, n_ctx)).view(1, 1, n_ctx, n_ctx))
self.n_head = cfg.n_head
self.split_size = n_state
self.scale = scale
self.c_attn = Conv1D(n_state * 3, 1, nx)
self.c_proj = Conv1D(n_state, 1, nx)
self.attn_dropout = nn.Dropout(cfg.attn_pdrop)
self.resid_dropout = nn.Dropout(cfg.resid_pdrop)
def _attn(self, q, k, v):
w = torch.matmul(q, k)
if self.scale:
w = w / math.sqrt(v.size(-1))
# w = w * self.b + -1e9 * (1 - self.b) # TF implem method: mask_attn_weights
# XD: self.b may be larger than w, so we need to crop it
b = self.b[:, :, (w.size(-1)-w.size(-2)):w.size(-1), :w.size(-1)]
w = w * b + -1e9 * (1 - b)
w = nn.Softmax(dim=-1)(w)
w = self.attn_dropout(w)
return torch.matmul(w, v)
def merge_heads(self, x):
x = x.permute(0, 2, 1, 3).contiguous()
new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)
return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states
def split_heads(self, x, k=False):
new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)
x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states
if k:
return x.permute(0, 2, 3, 1)
else:
return x.permute(0, 2, 1, 3)
def forward(self, x, pre_key=None, pre_value=None):
x = self.c_attn(x)
query, key, value = x.split(self.split_size, dim=2)
query = self.split_heads(query)
key = self.split_heads(key, k=True)
value = self.split_heads(value)
# prevent recalculation
if pre_key is not None and pre_value is not None:
key = torch.cat([pre_key, key], dim=-1)
value = torch.cat([pre_value, value], dim=-2)
a = self._attn(query, key, value)
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a)
return a, key, value
class MLP(nn.Module):
def __init__(self, n_state, cfg): # in MLP: n_state=3072 (4 * n_embd)
super(MLP, self).__init__()
nx = cfg.n_embd
self.c_fc = Conv1D(n_state, 1, nx)
self.c_proj = Conv1D(nx, 1, n_state)
self.act = ACT_FNS[cfg.afn]
self.dropout = nn.Dropout(cfg.resid_pdrop)
def forward(self, x):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
return self.dropout(h2)
############## pretrained model loader ###########
| size_out = x.size()[:-1] + (self.nf,)
x = torch.addmm(self.b, x.view(-1, x.size(-1)), self.w)
x = x.view(*size_out) | conditional_block |
model.py | def forward(self, x, pre_sts=None, last_only=False):
"""
:param x: the input sequence
:param pre_sts: to prevent recalculation. the prefix sequence's hidden states and Q,V saved in previous turn.
:return: logits of vocab words
"""
sts = self.transformer(x, pre_sts)
lm_logits = self.lm_head(sts[-1][0], last_only)
return lm_logits, sts
############## components ########################
##################################################
class LMHead(nn.Module):
""" Language Model Head for the transformer """
def __init__(self, model, cfg, n_vocab):
super(LMHead, self).__init__()
self.n_embd = cfg.n_embd
embed_shape = model.embed.weight.shape
self.decoder = nn.Linear(embed_shape[1], embed_shape[0], bias=False)
self.decoder.weight = model.embed.weight # Tied weights
self.n_decoding_vocab = n_vocab + 2 # and SOS, EOS
def forward(self, h, last_only=False):
if last_only:
h = h[:, -1:, :]
lm_logits = self.decoder(h)
return lm_logits[:, :, :self.n_decoding_vocab]
class TransformerModel(nn.Module):
""" Transformer model """
def __init__(self, cfg, n_indexs, n_ctx):
super(TransformerModel, self).__init__()
self.embed = nn.Embedding(n_indexs, cfg.n_embd)
self.drop = nn.Dropout(cfg.embd_pdrop)
block = Block(n_ctx, cfg, scale=True)
self.h = nn.ModuleList([copy.deepcopy(block) for _ in range(cfg.n_layer)])
nn.init.normal_(self.embed.weight, std=0.02)
def forward(self, x, pre_sts=None):
# for training mode
if pre_sts is None:
e = self.drop(self.embed(x))
# Add the position information to the input embeddings
h = e.sum(dim=2)
# for eval mode
else:
# get newly added words' embeddings
prev_len = pre_sts[0].size(1)
e_new = self.drop(self.embed(x[:, prev_len:, :]))
h_new = e_new.sum(dim=2)
h = torch.cat([pre_sts[0], h_new], dim=1)
# record the output hidden states of each layer
sts = []
sts.append(h)
for i, block in enumerate(self.h):
# pre_h the prefix sequence's hidden states of the current layer
pre_h, pre_k, pre_v = pre_sts[i+1] if pre_sts is not None else (None, None, None)
h, k, v = block(h, pre_h, pre_k, pre_v)
sts.append((h, k, v))
return sts
class Block(nn.Module):
def __init__(self, n_ctx, cfg, scale=False):
super(Block, self).__init__()
nx = cfg.n_embd
self.attn = Attention(nx, n_ctx, cfg, scale)
self.ln_1 = LayerNorm(nx)
self.mlp = MLP(4 * nx, cfg)
self.ln_2 = LayerNorm(nx)
def forward(self, x, pre_h=None, pre_key=None, pre_value=None):
l_needed = x.shape[1] if pre_h is None else x.shape[1] - pre_h.shape[1]
x_needed = x[:, -l_needed:, :]
a, key, value = self.attn(x_needed, pre_key, pre_value)
n = self.ln_1(x_needed + a)
m = self.mlp(n)
h = self.ln_2(n + m)
if pre_h is not None:
h = torch.cat([pre_h, h], dim=1)
return h, key, value
class LayerNorm(nn.Module):
"Construct a layernorm module in the OpenAI style (epsilon inside the square root)."
def __init__(self, n_state, e=1e-5):
super(LayerNorm, self).__init__()
self.g = nn.Parameter(torch.ones(n_state))
self.b = nn.Parameter(torch.zeros(n_state))
self.e = e
def forward(self, x):
u = x.mean(-1, keepdim=True)
s = (x - u).pow(2).mean(-1, keepdim=True)
x = (x - u) / torch.sqrt(s + self.e)
return self.g * x + self.b
class Conv1D(nn.Module):
def __init__(self, nf, rf, nx):
super(Conv1D, self).__init__()
self.rf = rf
self.nf = nf
if rf == 1: # faster 1x1 conv
w = torch.empty(nx, nf)
nn.init.normal_(w, std=0.02)
self.w = Parameter(w)
self.b = Parameter(torch.zeros(nf))
else: # was used to train LM
raise NotImplementedError
def forward(self, x):
if self.rf == 1:
size_out = x.size()[:-1] + (self.nf,)
x = torch.addmm(self.b, x.view(-1, x.size(-1)), self.w)
x = x.view(*size_out)
else:
raise NotImplementedError
return x
class Attention(nn.Module):
def __init__(self, nx, n_ctx, cfg, scale=False):
super(Attention, self).__init__()
n_state = nx # in Attention: n_state=768 (nx=n_embd)
# [switch nx => n_state from Block to Attention to keep identical to TF implem]
assert n_state % cfg.n_head == 0
self.register_buffer('b', torch.tril(torch.ones(n_ctx, n_ctx)).view(1, 1, n_ctx, n_ctx))
self.n_head = cfg.n_head
self.split_size = n_state
self.scale = scale
self.c_attn = Conv1D(n_state * 3, 1, nx)
self.c_proj = Conv1D(n_state, 1, nx)
self.attn_dropout = nn.Dropout(cfg.attn_pdrop)
self.resid_dropout = nn.Dropout(cfg.resid_pdrop)
def _attn(self, q, k, v):
w = torch.matmul(q, k)
if self.scale:
w = w / math.sqrt(v.size(-1))
# w = w * self.b + -1e9 * (1 - self.b) # TF implem method: mask_attn_weights
# XD: self.b may be larger than w, so we need to crop it
b = self.b[:, :, (w.size(-1)-w.size(-2)):w.size(-1), :w.size(-1)]
w = w * b + -1e9 * (1 - b)
w = nn.Softmax(dim=-1)(w)
w = self.attn_dropout(w)
return torch.matmul(w, v)
def merge_heads(self, x):
x = x.permute(0, 2, 1, 3).contiguous()
new_x_shape = x.size()[:-2] + (x.size(-2) * x.size(-1),)
return x.view(*new_x_shape) # in Tensorflow implem: fct merge_states
def split_heads(self, x, k=False):
new_x_shape = x.size()[:-1] + (self.n_head, x.size(-1) // self.n_head)
x = x.view(*new_x_shape) # in Tensorflow implem: fct split_states
if k:
return x.permute(0, 2, 3, 1)
else:
return x.permute(0, 2, 1, 3)
def | (self, x, pre_key=None, pre_value=None):
x = self.c_attn(x)
query, key, value = x.split(self.split_size, dim=2)
query = self.split_heads(query)
key = self.split_heads(key, k=True)
value = self.split_heads(value)
# prevent recalculation
if pre_key is not None and pre_value is not None:
key = torch.cat([pre_key, key], dim=-1)
value = torch.cat([pre_value, value], dim=-2)
a = self._attn(query, key, value)
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a)
return a, key, value
class MLP(nn.Module):
def __init__(self, n_state, cfg): # in MLP: n_state=3072 (4 * n_embd)
super(MLP, self).__init__()
nx = cfg.n_embd
self.c_fc = Conv1D(n_state, 1, nx)
self.c_proj = Conv1D(nx, 1, n_state)
self.act = ACT_FNS[cfg.afn]
self.dropout = nn.Dropout(cfg.resid_pdrop)
def forward(self, x):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
return self.dropout(h2)
############## pretrained model loader ###########
| forward | identifier_name |
manager.rs |
fn create_network_config() -> Result<Rc<RefCell<NetworkConfig>>> {
let mut network = NetworkConfig::new();
network.add_bridge("clear", "172.17.0.0/24")?;
Ok(Rc::new(RefCell::new(network)))
}
pub fn load() -> Result<RealmManager> {
let mut manager = RealmManager::new()?;
manager.symlinks.borrow_mut().load_symlinks()?;
if ! PathBuf::from(REALMS_BASE_PATH).exists() {
bail!("realms base directory {} does not exist", REALMS_BASE_PATH);
}
for dent in fs::read_dir(REALMS_BASE_PATH)? {
let path = dent?.path();
manager.process_realm_path(&path)
.map_err(|e| format_err!("error processing entry {} in realm base dir: {}", path.display(), e))?;
}
manager.realm_list.sort_unstable();
Ok(manager)
}
///
/// Process `path` as an entry from the base realms directory and
/// if `path` is a directory, and directory name has prefix "realm-"
/// extract chars after prefix as realm name and add a new `Realm`
/// instance
///
fn process_realm_path(&mut self, path: &Path) -> Result<()> {
let meta = path.symlink_metadata()?;
if !meta.is_dir() {
return Ok(())
}
let fname = path_filename(path);
if !fname.starts_with("realm-") {
return Ok(())
}
let (_, realm_name) = fname.split_at(6);
if !is_valid_realm_name(realm_name) {
warn!("ignoring directory in realm storage which has invalid realm name: {}", realm_name);
return Ok(())
}
let rootfs = path.join("rootfs");
if !rootfs.exists() {
warn!("realm directory {} does not have a rootfs, ignoring", path.display());
return Ok(())
}
match Realm::new(realm_name, self.symlinks.clone(), self.network.clone()) {
Ok(realm) => { self.add_realm_entry(realm);} ,
Err(e) => warn!("Ignoring '{}': {}", realm_name, e),
};
Ok(())
}
fn add_realm_entry(&mut self, realm: Realm) -> &Realm {
self.realm_map.insert(realm.name().to_owned(), realm.clone());
self.realm_list.push(realm.clone());
self.realm_map.get(realm.name()).expect("cannot find realm we just added to map")
}
fn remove_realm_entry(&mut self, name: &str) -> Result<()> {
self.realm_map.remove(name);
let list = self.realm_list.clone();
let mut have_default = false;
self.realm_list.clear();
for realm in list {
if realm.name() != name {
if realm.is_default() {
have_default = true;
}
self.realm_list.push(realm);
}
}
if !have_default && !self.realm_list.is_empty() {
self.symlinks.borrow_mut().set_default_symlink(self.realm_list[0].name())?;
}
Ok(())
}
pub fn current_realm_name(&self) -> Option<String> {
self.symlinks.borrow().current()
}
pub fn default_realm_name(&self) -> Option<String> {
self.symlinks.borrow().default()
}
///
/// Execute shell in a realm. If `realm_name` is `None` then exec
/// shell in current realm, otherwise look up realm by name.
///
/// If `root_shell` is true, open a root shell, otherwise open
/// a user (uid = 1000) shell.
///
pub fn launch_shell(&self, realm_name: Option<&str>, root_shell: bool) -> Result<()> {
let run_shell = |realm: &Realm| {
info!("opening shell in realm '{}'", realm.name());
realm.exec_shell(root_shell)?;
info!("exiting shell in realm '{}'", realm.name());
Ok(())
};
if let Some(name) = realm_name {
self.with_named_realm(name, true, run_shell)
} else {
self.with_current_realm(run_shell)
}
}
pub fn launch_terminal(&self, name: Option<&str>) -> Result<()> {
let run_terminal = |realm: &Realm| {
info!("opening terminal in realm '{}'", realm.name());
let title_arg = format!("Realm: {}", realm.name());
realm.run(&["/usr/bin/gnome-terminal".to_owned(), "--title".to_owned(), title_arg], true)
};
if let Some(name) = name {
self.with_named_realm(name, true, run_terminal)
} else {
self.with_current_realm(run_terminal)
}
}
pub fn run_in_realm(&self, realm_name: Option<&str>, args: &[String], use_launcher: bool) -> Result<()> {
if let Some(name) = realm_name {
self.with_named_realm(name, true, |realm| realm.run(args, use_launcher))
} else {
self.with_current_realm(|realm| realm.run(args, use_launcher))
}
}
fn with_current_realm<F: Fn(&Realm)->Result<()>>(&self, f: F) -> Result<()> {
match self.symlinks.borrow().current() {
Some(ref name) => {
self.with_named_realm(name, false, f)?;
},
None => {
warn!("No current realm instance to run command in");
}
}
Ok(())
}
fn with_named_realm<F: Fn(&Realm)->Result<()>>(&self, name: &str, want_start: bool, f: F) -> Result<()> {
match self.realm(name) {
Some(realm) => {
if want_start && !realm.is_running()? {
info!("realm '{}' is not running, starting it.", realm.name());
self.start_realm(realm)?;
}
f(realm)
},
None => bail!("no realm with name '{}' exists", name),
}
}
pub fn list(&self) -> Result<()> {
let mut out = ColoredOutput::new();
self.print_realm_header(&mut out);
for realm in &self.realm_list {
self.print_realm(realm, &mut out)?;
}
Ok(())
}
fn print_realm_header(&self, out: &mut ColoredOutput) {
out.write(" REALMS ").bold("bold").write(": current, ").bright("colored")
.write(": running, (default) starts on boot\n").write(" ------\n\n");
}
fn print_realm(&self, realm: &Realm, out: &mut ColoredOutput) -> Result<()> {
let name = format!("{:12}", realm.name());
if realm.is_current() {
out.write(" > ").bold(&name);
} else if realm.is_running()? {
out.write(" ").bright(&name);
} else {
out.write(" ").dim(&name);
}
if realm.is_default() {
out.write(" (default)");
}
out.write("\n");
Ok(())
}
pub fn start_default(&mut self) -> Result<()> {
let default = self.symlinks.borrow().default();
if let Some(ref realm_name) = default {
self.start_named_realm(realm_name)?;
return Ok(());
}
bail!("No default realm to start");
}
pub fn start_named_realm(&mut self, realm_name: &str) -> Result<()> {
info!("starting realm '{}'", realm_name);
self.with_named_realm(realm_name, false, |realm| self.start_realm(realm))
}
fn start_realm(&self, realm: &Realm) -> Result<()> {
let mut symlinks = self.symlinks.borrow_mut();
let no_current_realm = symlinks.current().is_none();
// no realm is current, so make this realm the current one
// service file for realm will also start desktopd, so this symlink
// must be created before launching realm.
if no_current_realm {
symlinks.set_current_symlink(Some(realm.name()))?;
}
if let Err(e) = realm.start() {
if no_current_realm {
// oops realm failed to start, need to reset symlink we changed
symlinks.set_current_symlink(None)?;
}
return Err(e);
}
Ok(())
}
pub fn stop_realm(&mut self, name: &str) -> Result<()> {
match self.realm_map.get(name) {
Some(realm) => {
realm.stop()?;
self.set_current_if_none()?;
},
None => {
warn!("Cannot stop '{}'. Realm does not exist", name);
return Ok(())
},
};
Ok(())
}
fn set_current_if_none(&self) -> Result<()> {
let mut symlinks = self.symlinks.borrow_mut();
| {
let network = RealmManager::create_network_config()?;
Ok(RealmManager {
realm_map: HashMap::new(),
realm_list: Vec::new(),
symlinks: Rc::new(RefCell::new(RealmSymlinks::new())),
network: network.clone(),
systemd: Systemd::new(network),
})
} | identifier_body | |
manager.rs | .borrow_mut().load_symlinks()?;
if ! PathBuf::from(REALMS_BASE_PATH).exists() {
bail!("realms base directory {} does not exist", REALMS_BASE_PATH);
}
for dent in fs::read_dir(REALMS_BASE_PATH)? {
let path = dent?.path();
manager.process_realm_path(&path)
.map_err(|e| format_err!("error processing entry {} in realm base dir: {}", path.display(), e))?;
}
manager.realm_list.sort_unstable();
Ok(manager)
}
///
/// Process `path` as an entry from the base realms directory and
/// if `path` is a directory, and directory name has prefix "realm-"
/// extract chars after prefix as realm name and add a new `Realm`
/// instance
///
fn process_realm_path(&mut self, path: &Path) -> Result<()> {
let meta = path.symlink_metadata()?;
if !meta.is_dir() {
return Ok(())
}
let fname = path_filename(path);
if !fname.starts_with("realm-") {
return Ok(())
}
let (_, realm_name) = fname.split_at(6);
if !is_valid_realm_name(realm_name) {
warn!("ignoring directory in realm storage which has invalid realm name: {}", realm_name);
return Ok(())
}
let rootfs = path.join("rootfs");
if !rootfs.exists() {
warn!("realm directory {} does not have a rootfs, ignoring", path.display());
return Ok(())
}
match Realm::new(realm_name, self.symlinks.clone(), self.network.clone()) {
Ok(realm) => { self.add_realm_entry(realm);} ,
Err(e) => warn!("Ignoring '{}': {}", realm_name, e),
};
Ok(())
}
fn add_realm_entry(&mut self, realm: Realm) -> &Realm {
self.realm_map.insert(realm.name().to_owned(), realm.clone());
self.realm_list.push(realm.clone());
self.realm_map.get(realm.name()).expect("cannot find realm we just added to map")
}
fn remove_realm_entry(&mut self, name: &str) -> Result<()> {
self.realm_map.remove(name);
let list = self.realm_list.clone();
let mut have_default = false;
self.realm_list.clear();
for realm in list {
if realm.name() != name {
if realm.is_default() {
have_default = true;
}
self.realm_list.push(realm);
}
}
if !have_default && !self.realm_list.is_empty() {
self.symlinks.borrow_mut().set_default_symlink(self.realm_list[0].name())?;
}
Ok(())
}
pub fn current_realm_name(&self) -> Option<String> {
self.symlinks.borrow().current()
}
pub fn default_realm_name(&self) -> Option<String> {
self.symlinks.borrow().default()
}
///
/// Execute shell in a realm. If `realm_name` is `None` then exec
/// shell in current realm, otherwise look up realm by name.
///
/// If `root_shell` is true, open a root shell, otherwise open
/// a user (uid = 1000) shell.
///
pub fn launch_shell(&self, realm_name: Option<&str>, root_shell: bool) -> Result<()> {
let run_shell = |realm: &Realm| {
info!("opening shell in realm '{}'", realm.name());
realm.exec_shell(root_shell)?;
info!("exiting shell in realm '{}'", realm.name());
Ok(())
};
if let Some(name) = realm_name {
self.with_named_realm(name, true, run_shell)
} else {
self.with_current_realm(run_shell)
}
}
pub fn launch_terminal(&self, name: Option<&str>) -> Result<()> {
let run_terminal = |realm: &Realm| {
info!("opening terminal in realm '{}'", realm.name());
let title_arg = format!("Realm: {}", realm.name());
realm.run(&["/usr/bin/gnome-terminal".to_owned(), "--title".to_owned(), title_arg], true)
};
if let Some(name) = name {
self.with_named_realm(name, true, run_terminal)
} else {
self.with_current_realm(run_terminal)
}
}
pub fn run_in_realm(&self, realm_name: Option<&str>, args: &[String], use_launcher: bool) -> Result<()> {
if let Some(name) = realm_name {
self.with_named_realm(name, true, |realm| realm.run(args, use_launcher))
} else {
self.with_current_realm(|realm| realm.run(args, use_launcher))
}
}
fn with_current_realm<F: Fn(&Realm)->Result<()>>(&self, f: F) -> Result<()> {
match self.symlinks.borrow().current() {
Some(ref name) => {
self.with_named_realm(name, false, f)?;
},
None => {
warn!("No current realm instance to run command in");
}
}
Ok(())
}
fn with_named_realm<F: Fn(&Realm)->Result<()>>(&self, name: &str, want_start: bool, f: F) -> Result<()> {
match self.realm(name) {
Some(realm) => {
if want_start && !realm.is_running()? {
info!("realm '{}' is not running, starting it.", realm.name());
self.start_realm(realm)?;
}
f(realm)
},
None => bail!("no realm with name '{}' exists", name),
}
}
pub fn list(&self) -> Result<()> {
let mut out = ColoredOutput::new();
self.print_realm_header(&mut out);
for realm in &self.realm_list {
self.print_realm(realm, &mut out)?;
}
Ok(())
}
fn print_realm_header(&self, out: &mut ColoredOutput) {
out.write(" REALMS ").bold("bold").write(": current, ").bright("colored")
.write(": running, (default) starts on boot\n").write(" ------\n\n");
}
fn print_realm(&self, realm: &Realm, out: &mut ColoredOutput) -> Result<()> {
let name = format!("{:12}", realm.name());
if realm.is_current() {
out.write(" > ").bold(&name);
} else if realm.is_running()? {
out.write(" ").bright(&name);
} else {
out.write(" ").dim(&name);
}
if realm.is_default() {
out.write(" (default)");
}
out.write("\n");
Ok(())
}
pub fn start_default(&mut self) -> Result<()> {
let default = self.symlinks.borrow().default();
if let Some(ref realm_name) = default {
self.start_named_realm(realm_name)?;
return Ok(());
}
bail!("No default realm to start");
}
pub fn start_named_realm(&mut self, realm_name: &str) -> Result<()> {
info!("starting realm '{}'", realm_name);
self.with_named_realm(realm_name, false, |realm| self.start_realm(realm))
}
fn start_realm(&self, realm: &Realm) -> Result<()> {
let mut symlinks = self.symlinks.borrow_mut();
let no_current_realm = symlinks.current().is_none();
// no realm is current, so make this realm the current one
// service file for realm will also start desktopd, so this symlink
// must be created before launching realm.
if no_current_realm {
symlinks.set_current_symlink(Some(realm.name()))?;
}
if let Err(e) = realm.start() {
if no_current_realm {
// oops realm failed to start, need to reset symlink we changed
symlinks.set_current_symlink(None)?;
}
return Err(e);
}
Ok(())
}
pub fn stop_realm(&mut self, name: &str) -> Result<()> {
match self.realm_map.get(name) {
Some(realm) => {
realm.stop()?;
self.set_current_if_none()?;
},
None => {
warn!("Cannot stop '{}'. Realm does not exist", name);
return Ok(())
},
};
Ok(())
}
fn set_current_if_none(&self) -> Result<()> {
let mut symlinks = self.symlinks.borrow_mut();
if symlinks.current().is_some() {
return Ok(());
}
if let Some(ref name) = self.find_running_realm_name()? {
symlinks.set_current_symlink(Some(name))?;
self.systemd.restart_desktopd()?;
} else {
self.systemd.stop_desktopd()?;
}
Ok(())
}
fn find_running_realm_name(&self) -> Result<Option<String>> {
for realm in self.realm_map.values() {
if realm.is_running()? {
return Ok(Some(realm.name().to_string()));
}
}
Ok(None)
}
pub fn set_current_by_name(&self, realm_name: &str) -> Result<()> {
self.with_named_realm(realm_name, false, |realm| realm.set_current())
} | random_line_split | ||
manager.rs | RefCell::new(network)))
}
pub fn load() -> Result<RealmManager> {
let mut manager = RealmManager::new()?;
manager.symlinks.borrow_mut().load_symlinks()?;
if ! PathBuf::from(REALMS_BASE_PATH).exists() {
bail!("realms base directory {} does not exist", REALMS_BASE_PATH);
}
for dent in fs::read_dir(REALMS_BASE_PATH)? {
let path = dent?.path();
manager.process_realm_path(&path)
.map_err(|e| format_err!("error processing entry {} in realm base dir: {}", path.display(), e))?;
}
manager.realm_list.sort_unstable();
Ok(manager)
}
///
/// Process `path` as an entry from the base realms directory and
/// if `path` is a directory, and directory name has prefix "realm-"
/// extract chars after prefix as realm name and add a new `Realm`
/// instance
///
fn process_realm_path(&mut self, path: &Path) -> Result<()> {
let meta = path.symlink_metadata()?;
if !meta.is_dir() {
return Ok(())
}
let fname = path_filename(path);
if !fname.starts_with("realm-") {
return Ok(())
}
let (_, realm_name) = fname.split_at(6);
if !is_valid_realm_name(realm_name) {
warn!("ignoring directory in realm storage which has invalid realm name: {}", realm_name);
return Ok(())
}
let rootfs = path.join("rootfs");
if !rootfs.exists() {
warn!("realm directory {} does not have a rootfs, ignoring", path.display());
return Ok(())
}
match Realm::new(realm_name, self.symlinks.clone(), self.network.clone()) {
Ok(realm) => { self.add_realm_entry(realm);} ,
Err(e) => warn!("Ignoring '{}': {}", realm_name, e),
};
Ok(())
}
fn | (&mut self, realm: Realm) -> &Realm {
self.realm_map.insert(realm.name().to_owned(), realm.clone());
self.realm_list.push(realm.clone());
self.realm_map.get(realm.name()).expect("cannot find realm we just added to map")
}
fn remove_realm_entry(&mut self, name: &str) -> Result<()> {
self.realm_map.remove(name);
let list = self.realm_list.clone();
let mut have_default = false;
self.realm_list.clear();
for realm in list {
if realm.name() != name {
if realm.is_default() {
have_default = true;
}
self.realm_list.push(realm);
}
}
if !have_default && !self.realm_list.is_empty() {
self.symlinks.borrow_mut().set_default_symlink(self.realm_list[0].name())?;
}
Ok(())
}
pub fn current_realm_name(&self) -> Option<String> {
self.symlinks.borrow().current()
}
pub fn default_realm_name(&self) -> Option<String> {
self.symlinks.borrow().default()
}
///
/// Execute shell in a realm. If `realm_name` is `None` then exec
/// shell in current realm, otherwise look up realm by name.
///
/// If `root_shell` is true, open a root shell, otherwise open
/// a user (uid = 1000) shell.
///
pub fn launch_shell(&self, realm_name: Option<&str>, root_shell: bool) -> Result<()> {
let run_shell = |realm: &Realm| {
info!("opening shell in realm '{}'", realm.name());
realm.exec_shell(root_shell)?;
info!("exiting shell in realm '{}'", realm.name());
Ok(())
};
if let Some(name) = realm_name {
self.with_named_realm(name, true, run_shell)
} else {
self.with_current_realm(run_shell)
}
}
pub fn launch_terminal(&self, name: Option<&str>) -> Result<()> {
let run_terminal = |realm: &Realm| {
info!("opening terminal in realm '{}'", realm.name());
let title_arg = format!("Realm: {}", realm.name());
realm.run(&["/usr/bin/gnome-terminal".to_owned(), "--title".to_owned(), title_arg], true)
};
if let Some(name) = name {
self.with_named_realm(name, true, run_terminal)
} else {
self.with_current_realm(run_terminal)
}
}
pub fn run_in_realm(&self, realm_name: Option<&str>, args: &[String], use_launcher: bool) -> Result<()> {
if let Some(name) = realm_name {
self.with_named_realm(name, true, |realm| realm.run(args, use_launcher))
} else {
self.with_current_realm(|realm| realm.run(args, use_launcher))
}
}
fn with_current_realm<F: Fn(&Realm)->Result<()>>(&self, f: F) -> Result<()> {
match self.symlinks.borrow().current() {
Some(ref name) => {
self.with_named_realm(name, false, f)?;
},
None => {
warn!("No current realm instance to run command in");
}
}
Ok(())
}
fn with_named_realm<F: Fn(&Realm)->Result<()>>(&self, name: &str, want_start: bool, f: F) -> Result<()> {
match self.realm(name) {
Some(realm) => {
if want_start && !realm.is_running()? {
info!("realm '{}' is not running, starting it.", realm.name());
self.start_realm(realm)?;
}
f(realm)
},
None => bail!("no realm with name '{}' exists", name),
}
}
pub fn list(&self) -> Result<()> {
let mut out = ColoredOutput::new();
self.print_realm_header(&mut out);
for realm in &self.realm_list {
self.print_realm(realm, &mut out)?;
}
Ok(())
}
fn print_realm_header(&self, out: &mut ColoredOutput) {
out.write(" REALMS ").bold("bold").write(": current, ").bright("colored")
.write(": running, (default) starts on boot\n").write(" ------\n\n");
}
fn print_realm(&self, realm: &Realm, out: &mut ColoredOutput) -> Result<()> {
let name = format!("{:12}", realm.name());
if realm.is_current() {
out.write(" > ").bold(&name);
} else if realm.is_running()? {
out.write(" ").bright(&name);
} else {
out.write(" ").dim(&name);
}
if realm.is_default() {
out.write(" (default)");
}
out.write("\n");
Ok(())
}
pub fn start_default(&mut self) -> Result<()> {
let default = self.symlinks.borrow().default();
if let Some(ref realm_name) = default {
self.start_named_realm(realm_name)?;
return Ok(());
}
bail!("No default realm to start");
}
pub fn start_named_realm(&mut self, realm_name: &str) -> Result<()> {
info!("starting realm '{}'", realm_name);
self.with_named_realm(realm_name, false, |realm| self.start_realm(realm))
}
fn start_realm(&self, realm: &Realm) -> Result<()> {
let mut symlinks = self.symlinks.borrow_mut();
let no_current_realm = symlinks.current().is_none();
// no realm is current, so make this realm the current one
// service file for realm will also start desktopd, so this symlink
// must be created before launching realm.
if no_current_realm {
symlinks.set_current_symlink(Some(realm.name()))?;
}
if let Err(e) = realm.start() {
if no_current_realm {
// oops realm failed to start, need to reset symlink we changed
symlinks.set_current_symlink(None)?;
}
return Err(e);
}
Ok(())
}
pub fn stop_realm(&mut self, name: &str) -> Result<()> {
match self.realm_map.get(name) {
Some(realm) => {
realm.stop()?;
self.set_current_if_none()?;
},
None => {
warn!("Cannot stop '{}'. Realm does not exist", name);
return Ok(())
},
};
Ok(())
}
fn set_current_if_none(&self) -> Result<()> {
let mut symlinks = self.symlinks.borrow_mut();
if symlinks.current().is_some() {
return Ok(());
}
if let Some(ref name) = self.find_running_realm_name()? {
symlinks.set_current_symlink(Some(name))?;
self.systemd.restart_desktopd()?;
} else {
self.systemd.stop_desktopd()?;
}
Ok(())
}
fn find_running_realm_name(&self) -> Result<Option<String>> {
for realm in self.realm_map.values() {
if realm.is_running()? {
return Ok(Some(realm.name().to_string()));
}
}
Ok(None)
}
pub fn set_current | add_realm_entry | identifier_name |
Multiple_PhotometryConstruction.py | plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
else:
for i in range(0, len(Subjects_465)):
fig1 = plt.figure()
plt.plot(time[i],Subjects_465[i].data, color='green', label = 'Gcamp6f')
plt.plot(time[i],Subjects_405[i].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:'+ subjs[i])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
return trim, note
def trim_and_process(trim,end,timex,s465,s405):
# trim data
trimmed_s465 = []
trimmed_s405 = []
trimmed_time = []
dFF = []
std_dFF = []
baseline = []
y_all = []
y_df = []
s_ind = []
e_ind = []
if len(s465) == 1:
s_ind.append(np.where(timex[0] > trim[0])[0][0])
e_ind.append(np.where(timex[0] > end)[0][0])
trimmed_time.append(timex[0][s_ind[0]:e_ind[0]])
trimmed_s465.append(s465[0].data[s_ind[0]:e_ind[0]])
trimmed_s405.append(s405[0].data[s_ind[0]:e_ind[0]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[0]), np.array(trimmed_s465[0]), 1))
y_all.append(np.multiply(baseline[0][0], np.array(trimmed_s405[0])) + baseline[0][1])
y_df.append(np.array(trimmed_s465[0]) - y_all[0])
dFF.append(np.multiply(100,np.divide(y_df[0],y_all[0])))
std_dFF.append(np.std(dFF[0]))
else:
for i in range(0, len(s465)):
s_ind.append(np.where(timex[i] > trim[i])[0][0])
e_ind.append(np.where(timex[i] > end)[0][0])
trimmed_time.append(timex[i][s_ind[i]:e_ind[i]])
trimmed_s465.append(s465[i].data[s_ind[i]:e_ind[i]])
trimmed_s405.append(s405[i].data[s_ind[i]:e_ind[i]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[i]), np.array(trimmed_s465[i]), 1))
y_all.append(np.multiply(baseline[i][0], np.array(trimmed_s405[i])) + baseline[i][1])
y_df.append(np.array(trimmed_s465[i]) - y_all[i])
dFF.append(np.multiply(100,np.divide(y_df[i],y_all[i])))
print("you can ignore that warning: when comparing polyfit to" +
" the equivalent in matlab, which gives no errors it yielded the same answer")
return [trimmed_time, dFF, std_dFF]
def send_fiber(data,subjects,session,notes):
md= MetaData(engine)
test_conn = engine.connect()
for s in range(0,len(notes)):
if not engine.dialect.has_table(test_conn,'photodata'):
photodata = Table('photodata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Note', String(length=100)),
Column('TimeX', DECIMAL(19,10)),
Column('dFF', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
photodata = Base.classes.photodata
#create data dictionary
list_session = [session]*len(data[0][s])
list_subject = [subjects[s]]*len(data[0][s])
list_notes = [notes[s]]*len(data[0][s])
print("reorganizing data for push to sql")
data_list_dicts = []
for i in range(0, len(data[0][s])):
data_list_dicts.append(dict(Subject=list_subject[i], Session=list_session[i],
Note=list_notes[i], TimeX=data[0][s][i].tolist(), dFF=data[1][s][i].tolist()))
print("pushing fiber data to SQL")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(photodata,data_list_dicts)
SQLsession.flush()
SQLsession.commit()
print("fiber data pushed to SQL db for subject:"+subjects[s])
SQLsession.close()
def sort_events(s,subjects,all_events):
event_list_dict = []
for i in range(0,len(subjects)):
if not all_events[i]:
print("empty events")
else:
for e in all_events[i]:
subject_list = [int(subjects[i])]*len(e.onset)
session_list = [s]*len(e.onset)
name_list = [e.name]*len(e.onset)
onset_list = e.onset.tolist()
offset_list = e.offset.tolist()
for j in range(0,len(onset_list)):
event_list_dict.append(dict(Subject = subject_list[j], Session = session_list[j],
Name = name_list[j], Onset = onset_list[j], Offset = offset_list[j]))
return event_list_dict
def send_events(event_list_dict):
md= MetaData(engine)
test_conn = engine.connect()
if not engine.dialect.has_table(test_conn,'eventdata'):
eventdata = Table('eventdata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Name', String(length=100)),
Column('Onset', DECIMAL(19,10)),
Column('Offset', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
eventdata = Base.classes.eventdata
print("pushing event data to sql")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(eventdata,event_list_dict)
SQLsession.flush()
SQLsession.commit()
print("event data pushed to SQL db for all subject")
SQLsession.close()
def pullfiberdata(s,f,import_tdt):
Subjects_465 = []
Subjects_405 = []
if '&' in f:
subjs = f.split()
subjs.remove('&')
else:
subjs = [f]
if len(subjs) == 1:
test465A = import_tdt.streams['_465A'].data[1000]
test465C = import_tdt.streams['_465C'].data[1000]
if test465A > test465C:
Subjects_465.append(import_tdt.streams['_465A'])
Subjects_405.append(import_tdt.streams['_405A'])
else:
Subjects_465.append(import_tdt.streams['_465C'])
Subjects_405.append(import_tdt.streams['_405C'])
else:
Subjects_465.append(import_tdt.streams['_465A'])
Subjects_405.append(import_tdt.streams['_405A'])
Subjects_465.append(import_tdt.streams['_465C'])
Subjects_405.append(import_tdt.streams['_405C'])
time = get_time(Subjects_465,Subjects_405)
trim, note = evaluate_rawdata(time, Subjects_465, Subjects_405, subjs)
processed_data = trim_and_process(trim,import_tdt.info.duration.seconds-1, time, Subjects_465, Subjects_405)
send_fiber(processed_data,subjs,s,note)
def | pulleventdata | identifier_name | |
Multiple_PhotometryConstruction.py |
def evaluate_rawdata(time,Subjects_465,Subjects_405, subjs):
trim = []
note = []
if len(Subjects_465) == 1:
fig1 = plt.figure()
plt.plot(time[0],Subjects_465[0].data, color='green', label = 'Gcamp6f')
plt.plot(time[0],Subjects_405[0].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:' + subjs[0])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
else:
for i in range(0, len(Subjects_465)):
fig1 = plt.figure()
plt.plot(time[i],Subjects_465[i].data, color='green', label = 'Gcamp6f')
plt.plot(time[i],Subjects_405[i].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:'+ subjs[i])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
return trim, note
def trim_and_process(trim,end,timex,s465,s405):
# trim data
trimmed_s465 = []
trimmed_s405 = []
trimmed_time = []
dFF = []
std_dFF = []
baseline = []
y_all = []
y_df = []
s_ind = []
e_ind = []
if len(s465) == 1:
s_ind.append(np.where(timex[0] > trim[0])[0][0])
e_ind.append(np.where(timex[0] > end)[0][0])
trimmed_time.append(timex[0][s_ind[0]:e_ind[0]])
trimmed_s465.append(s465[0].data[s_ind[0]:e_ind[0]])
trimmed_s405.append(s405[0].data[s_ind[0]:e_ind[0]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[0]), np.array(trimmed_s465[0]), 1))
y_all.append(np.multiply(baseline[0][0], np.array(trimmed_s405[0])) + baseline[0][1])
y_df.append(np.array(trimmed_s465[0]) - y_all[0])
dFF.append(np.multiply(100,np.divide(y_df[0],y_all[0])))
std_dFF.append(np.std(dFF[0]))
else:
for i in range(0, len(s465)):
s_ind.append(np.where(timex[i] > trim[i])[0][0])
e_ind.append(np.where(timex[i] > end)[0][0])
trimmed_time.append(timex[i][s_ind[i]:e_ind[i]])
trimmed_s465.append(s465[i].data[s_ind[i]:e_ind[i]])
trimmed_s405.append(s405[i].data[s_ind[i]:e_ind[i]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[i]), np.array(trimmed_s465[i]), 1))
y_all.append(np.multiply(baseline[i][0], np.array(trimmed_s405[i])) + baseline[i][1])
y_df.append(np.array(trimmed_s465[i]) - y_all[i])
dFF.append(np.multiply(100,np.divide(y_df[i],y_all[i])))
print("you can ignore that warning: when comparing polyfit to" +
" the equivalent in matlab, which gives no errors it yielded the same answer")
return [trimmed_time, dFF, std_dFF]
def send_fiber(data,subjects,session,notes):
md= MetaData(engine)
test_conn = engine.connect()
for s in range(0,len(notes)):
if not engine.dialect.has_table(test_conn,'photodata'):
photodata = Table('photodata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Note', String(length=100)),
Column('TimeX', DECIMAL(19,10)),
Column('dFF', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
photodata = Base.classes.photodata
#create data dictionary
list_session = [session]*len(data[0][s])
list_subject = [subjects[s]]*len(data[0][s])
list_notes = [notes[s]]*len(data[0][s])
print("reorganizing data for push to sql")
data_list_dicts = []
for i in range(0, len(data[0][s])):
data_list_dicts.append(dict(Subject=list_subject[i], Session=list_session[i],
Note=list_notes[i], TimeX=data[0][s][i].tolist(), dFF=data[1][s][i].tolist()))
print("pushing fiber data to SQL")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(photodata,data_list_dicts)
SQLsession.flush()
SQLsession.commit()
print("fiber data pushed to SQL db for subject:"+subjects[s])
SQLsession.close()
def sort_events(s,subjects,all_events):
event_list_dict = []
for i in range(0,len(subjects)):
if not all_events[i]:
print("empty events")
else:
for e in all_events[i]:
subject_list = [int(subjects[i])]*len(e.onset)
session_list = [s]*len(e.onset)
name_list = [e.name]*len(e.onset)
onset_list = e.onset.tolist()
offset_list = e.offset.tolist()
for j in range(0,len(onset_list)):
event_list_dict.append(dict(Subject = subject_list[j], Session = session_list[j],
Name = name_list[j], Onset = onset_list[j], Offset = offset_list[j]))
return event_list_dict
def send_events(event_list_dict):
md= MetaData(engine)
test_conn = engine.connect()
if not engine.dialect.has_table(test_conn,'eventdata'):
eventdata = Table('eventdata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Name', String(length=100)),
Column('Onset', DECIMAL(19,10)),
Column('Offset', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
eventdata = Base.classes.eventdata
print("pushing event data to sql")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(eventdata,event_list_dict)
SQLsession.flush()
SQLsession.commit()
print("event data pushed to SQL db for all subject")
SQLsession.close()
def pullfiberdata(s,f,import_tdt):
Subjects_465 = []
Subjects_405 = []
if '&' in f:
subjs = f.split()
subjs.remove('&')
else:
subjs = [f]
if len(subjs) == 1:
test465A = import_tdt.streams['_465A'].data[1000]
test465C = import_tdt.streams['_465C'].data[1000]
if test465A > test465C:
Subjects | timex = []
if len(s465) == 1:
timex.append(np.linspace(1,len(s465[0].data), len(s465[0].data))/s465[0].fs)
else:
for i in range(0, len(s465)):
timex.append(np.linspace(1,len(s465[i].data), len(s465[i].data))/s465[i].fs)
return timex | identifier_body | |
Multiple_PhotometryConstruction.py | 65[i].data))/s465[i].fs)
return timex
def evaluate_rawdata(time,Subjects_465,Subjects_405, subjs):
trim = []
note = []
if len(Subjects_465) == 1:
fig1 = plt.figure()
plt.plot(time[0],Subjects_465[0].data, color='green', label = 'Gcamp6f')
plt.plot(time[0],Subjects_405[0].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:' + subjs[0])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
else:
for i in range(0, len(Subjects_465)):
fig1 = plt.figure()
plt.plot(time[i],Subjects_465[i].data, color='green', label = 'Gcamp6f')
plt.plot(time[i],Subjects_405[i].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:'+ subjs[i])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
return trim, note
def trim_and_process(trim,end,timex,s465,s405):
# trim data
trimmed_s465 = []
trimmed_s405 = []
trimmed_time = []
dFF = []
std_dFF = []
baseline = []
y_all = []
y_df = []
s_ind = []
e_ind = []
if len(s465) == 1:
s_ind.append(np.where(timex[0] > trim[0])[0][0])
e_ind.append(np.where(timex[0] > end)[0][0])
trimmed_time.append(timex[0][s_ind[0]:e_ind[0]])
trimmed_s465.append(s465[0].data[s_ind[0]:e_ind[0]])
trimmed_s405.append(s405[0].data[s_ind[0]:e_ind[0]])
| y_all.append(np.multiply(baseline[0][0], np.array(trimmed_s405[0])) + baseline[0][1])
y_df.append(np.array(trimmed_s465[0]) - y_all[0])
dFF.append(np.multiply(100,np.divide(y_df[0],y_all[0])))
std_dFF.append(np.std(dFF[0]))
else:
for i in range(0, len(s465)):
s_ind.append(np.where(timex[i] > trim[i])[0][0])
e_ind.append(np.where(timex[i] > end)[0][0])
trimmed_time.append(timex[i][s_ind[i]:e_ind[i]])
trimmed_s465.append(s465[i].data[s_ind[i]:e_ind[i]])
trimmed_s405.append(s405[i].data[s_ind[i]:e_ind[i]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[i]), np.array(trimmed_s465[i]), 1))
y_all.append(np.multiply(baseline[i][0], np.array(trimmed_s405[i])) + baseline[i][1])
y_df.append(np.array(trimmed_s465[i]) - y_all[i])
dFF.append(np.multiply(100,np.divide(y_df[i],y_all[i])))
print("you can ignore that warning: when comparing polyfit to" +
" the equivalent in matlab, which gives no errors it yielded the same answer")
return [trimmed_time, dFF, std_dFF]
def send_fiber(data,subjects,session,notes):
md= MetaData(engine)
test_conn = engine.connect()
for s in range(0,len(notes)):
if not engine.dialect.has_table(test_conn,'photodata'):
photodata = Table('photodata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Note', String(length=100)),
Column('TimeX', DECIMAL(19,10)),
Column('dFF', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
photodata = Base.classes.photodata
#create data dictionary
list_session = [session]*len(data[0][s])
list_subject = [subjects[s]]*len(data[0][s])
list_notes = [notes[s]]*len(data[0][s])
print("reorganizing data for push to sql")
data_list_dicts = []
for i in range(0, len(data[0][s])):
data_list_dicts.append(dict(Subject=list_subject[i], Session=list_session[i],
Note=list_notes[i], TimeX=data[0][s][i].tolist(), dFF=data[1][s][i].tolist()))
print("pushing fiber data to SQL")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(photodata,data_list_dicts)
SQLsession.flush()
SQLsession.commit()
print("fiber data pushed to SQL db for subject:"+subjects[s])
SQLsession.close()
def sort_events(s,subjects,all_events):
event_list_dict = []
for i in range(0,len(subjects)):
if not all_events[i]:
print("empty events")
else:
for e in all_events[i]:
subject_list = [int(subjects[i])]*len(e.onset)
session_list = [s]*len(e.onset)
name_list = [e.name]*len(e.onset)
onset_list = e.onset.tolist()
offset_list = e.offset.tolist()
for j in range(0,len(onset_list)):
event_list_dict.append(dict(Subject = subject_list[j], Session = session_list[j],
Name = name_list[j], Onset = onset_list[j], Offset = offset_list[j]))
return event_list_dict
def send_events(event_list_dict):
md= MetaData(engine)
test_conn = engine.connect()
if not engine.dialect.has_table(test_conn,'eventdata'):
eventdata = Table('eventdata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Name', String(length=100)),
Column('Onset', DECIMAL(19,10)),
Column('Offset', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
eventdata = Base.classes.eventdata
print("pushing event data to sql")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(eventdata,event_list_dict)
SQLsession.flush()
SQLsession.commit()
print("event data pushed to SQL db for all subject")
SQLsession.close()
def pullfiberdata(s,f,import_tdt):
Subjects_465 = []
Subjects_405 = []
if '&' in f:
subjs = f.split()
subjs.remove('&')
else:
subjs = [f]
if len(subjs) == 1:
test465A = import_tdt.streams['_465A'].data[1000]
test465C = import_tdt.streams['_465C'].data[1000]
if test465A > test465C:
Subjects_465.append(import_tdt.streams['_465A'])
Subjects_405.append(import_tdt.streams['_405A'])
else:
Subjects_465.append(import_tdt.streams['_465C'])
Subjects_405.append(import_tdt.streams['_405C'])
else:
Subjects_465.append(import_tdt.streams['_4 | #process data
baseline.append(np.polyfit(np.array(trimmed_s405[0]), np.array(trimmed_s465[0]), 1)) | random_line_split |
Multiple_PhotometryConstruction.py | [i].data))/s465[i].fs)
return timex
def evaluate_rawdata(time,Subjects_465,Subjects_405, subjs):
trim = []
note = []
if len(Subjects_465) == 1:
fig1 = plt.figure()
plt.plot(time[0],Subjects_465[0].data, color='green', label = 'Gcamp6f')
plt.plot(time[0],Subjects_405[0].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:' + subjs[0])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
else:
for i in range(0, len(Subjects_465)):
fig1 = plt.figure()
plt.plot(time[i],Subjects_465[i].data, color='green', label = 'Gcamp6f')
plt.plot(time[i],Subjects_405[i].data, color='blueviolet', label = 'ISOS')
plt.ylabel('mV')
plt.xlabel('Seconds')
plt.title('Subject:'+ subjs[i])
plt.show()
while True:
try:
proceed = str(input("Does everything look okay?"))
if proceed == 'y':
trim.append(100)
note.append('All good')
break
elif proceed == 'n':
trim.append(int(input("Where should the trim begin?")))
note.append(str(input("Anything to record about these data")))
break
except ValueError:
print("Please enter y or n")
continue
return trim, note
def trim_and_process(trim,end,timex,s465,s405):
# trim data
trimmed_s465 = []
trimmed_s405 = []
trimmed_time = []
dFF = []
std_dFF = []
baseline = []
y_all = []
y_df = []
s_ind = []
e_ind = []
if len(s465) == 1:
s_ind.append(np.where(timex[0] > trim[0])[0][0])
e_ind.append(np.where(timex[0] > end)[0][0])
trimmed_time.append(timex[0][s_ind[0]:e_ind[0]])
trimmed_s465.append(s465[0].data[s_ind[0]:e_ind[0]])
trimmed_s405.append(s405[0].data[s_ind[0]:e_ind[0]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[0]), np.array(trimmed_s465[0]), 1))
y_all.append(np.multiply(baseline[0][0], np.array(trimmed_s405[0])) + baseline[0][1])
y_df.append(np.array(trimmed_s465[0]) - y_all[0])
dFF.append(np.multiply(100,np.divide(y_df[0],y_all[0])))
std_dFF.append(np.std(dFF[0]))
else:
for i in range(0, len(s465)):
s_ind.append(np.where(timex[i] > trim[i])[0][0])
e_ind.append(np.where(timex[i] > end)[0][0])
trimmed_time.append(timex[i][s_ind[i]:e_ind[i]])
trimmed_s465.append(s465[i].data[s_ind[i]:e_ind[i]])
trimmed_s405.append(s405[i].data[s_ind[i]:e_ind[i]])
#process data
baseline.append(np.polyfit(np.array(trimmed_s405[i]), np.array(trimmed_s465[i]), 1))
y_all.append(np.multiply(baseline[i][0], np.array(trimmed_s405[i])) + baseline[i][1])
y_df.append(np.array(trimmed_s465[i]) - y_all[i])
dFF.append(np.multiply(100,np.divide(y_df[i],y_all[i])))
print("you can ignore that warning: when comparing polyfit to" +
" the equivalent in matlab, which gives no errors it yielded the same answer")
return [trimmed_time, dFF, std_dFF]
def send_fiber(data,subjects,session,notes):
md= MetaData(engine)
test_conn = engine.connect()
for s in range(0,len(notes)):
if not engine.dialect.has_table(test_conn,'photodata'):
photodata = Table('photodata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Note', String(length=100)),
Column('TimeX', DECIMAL(19,10)),
Column('dFF', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
photodata = Base.classes.photodata
#create data dictionary
list_session = [session]*len(data[0][s])
list_subject = [subjects[s]]*len(data[0][s])
list_notes = [notes[s]]*len(data[0][s])
print("reorganizing data for push to sql")
data_list_dicts = []
for i in range(0, len(data[0][s])):
data_list_dicts.append(dict(Subject=list_subject[i], Session=list_session[i],
Note=list_notes[i], TimeX=data[0][s][i].tolist(), dFF=data[1][s][i].tolist()))
print("pushing fiber data to SQL")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(photodata,data_list_dicts)
SQLsession.flush()
SQLsession.commit()
print("fiber data pushed to SQL db for subject:"+subjects[s])
SQLsession.close()
def sort_events(s,subjects,all_events):
event_list_dict = []
for i in range(0,len(subjects)):
if not all_events[i]:
print("empty events")
else:
|
return event_list_dict
def send_events(event_list_dict):
md= MetaData(engine)
test_conn = engine.connect()
if not engine.dialect.has_table(test_conn,'eventdata'):
eventdata = Table('eventdata', md,
Column('idx', Integer, primary_key=True, nullable=False, autoincrement=True),
Column('Subject',Integer),
Column('Session',String(length=10)),
Column('Name', String(length=100)),
Column('Onset', DECIMAL(19,10)),
Column('Offset', DECIMAL(19,10)))
md.create_all(engine)
#pull table as a class
Base = automap_base()
Base.prepare(engine,reflect=True)
eventdata = Base.classes.eventdata
print("pushing event data to sql")
#start session
SQLsession = Session(engine)
SQLsession.bulk_insert_mappings(eventdata,event_list_dict)
SQLsession.flush()
SQLsession.commit()
print("event data pushed to SQL db for all subject")
SQLsession.close()
def pullfiberdata(s,f,import_tdt):
Subjects_465 = []
Subjects_405 = []
if '&' in f:
subjs = f.split()
subjs.remove('&')
else:
subjs = [f]
if len(subjs) == 1:
test465A = import_tdt.streams['_465A'].data[1000]
test465C = import_tdt.streams['_465C'].data[1000]
if test465A > test465C:
Subjects_465.append(import_tdt.streams['_465A'])
Subjects_405.append(import_tdt.streams['_405A'])
else:
Subjects_465.append(import_tdt.streams['_465C'])
Subjects_405.append(import_tdt.streams['_405C'])
else:
Subjects_465.append(import_tdt.streams['_46 | for e in all_events[i]:
subject_list = [int(subjects[i])]*len(e.onset)
session_list = [s]*len(e.onset)
name_list = [e.name]*len(e.onset)
onset_list = e.onset.tolist()
offset_list = e.offset.tolist()
for j in range(0,len(onset_list)):
event_list_dict.append(dict(Subject = subject_list[j], Session = session_list[j],
Name = name_list[j], Onset = onset_list[j], Offset = offset_list[j])) | conditional_block |
apps.go | ) | () (err error) {
var aids []int
if c.AccountID == 0 {
s := NewSpinner("Looking up accounts")
s.Start()
as, err := api.Accounts()
if err != nil {
return fmt.Errorf("unable to look up accounts: %w", err)
}
for _, a := range as {
aids = append(aids, a.ID)
}
s.Stop()
} else {
aids = append(aids, c.AccountID)
}
s := NewSpinner("Looking up apps")
s.Start()
apps := make(map[int][]api.App)
for _, id := range aids {
as, err := api.Applications(id)
if err != nil {
return fmt.Errorf("unable to look up applications: %w", err)
}
apps[id] = as
}
s.Stop()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Account ID", "App ID", "App Name"})
for id, as := range apps {
for _, a := range as {
r := []string{strconv.Itoa(id), strconv.Itoa(a.ID), a.ApplicationName}
table.Append(r)
}
}
table.Render()
return err
}
// AppsInfoCmd shows detailed information on an app running on Section
type AppsInfoCmd struct {
AccountID int `required short:"a"`
AppID int `required short:"i"`
}
// Run executes the command
func (c *AppsInfoCmd) Run() (err error) {
s := NewSpinner("Looking up app info")
s.Start()
app, err := api.Application(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("🌎🌏🌍\n")
fmt.Printf("App Name: %s\n", app.ApplicationName)
fmt.Printf("App ID: %d\n", app.ID)
fmt.Printf("Environment count: %d\n", len(app.Environments))
for i, env := range app.Environments {
fmt.Printf("\n-----------------\n\n")
fmt.Printf("Environment #%d: %s (ID:%d)\n\n", i+1, env.EnvironmentName, env.ID)
fmt.Printf("💬 Domains (%d total)\n", len(env.Domains))
for _, dom := range env.Domains {
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Attribute", "Value"})
table.SetAutoMergeCells(true)
r := [][]string{
[]string{"Domain name", dom.Name},
[]string{"Zone name", dom.ZoneName},
[]string{"CNAME", dom.CNAME},
[]string{"Mode", dom.Mode},
}
table.AppendBulk(r)
table.Render()
}
fmt.Println()
mod := "modules"
if len(env.Stack) == 1 {
mod = "module"
}
fmt.Printf("🥞 Stack (%d %s total)\n", len(env.Stack), mod)
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Name", "Image"})
table.SetAutoMergeCells(true)
for _, p := range env.Stack {
r := []string{p.Name, p.Image}
table.Append(r)
}
table.Render()
}
fmt.Println()
return err
}
// AppsCreateCmd handles creating apps on Section
type AppsCreateCmd struct {
AccountID int `required short:"a" help:"ID of account to create the app under"`
Hostname string `required short:"d" help:"FQDN the app can be accessed at"`
Origin string `required short:"o" help:"URL to fetch the origin"`
StackName string `required short:"s" help:"Name of stack to deploy"`
}
// Run executes the command
func (c *AppsCreateCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Creating new app %s", c.Hostname))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
r, err := api.ApplicationCreate(c.AccountID, c.Hostname, c.Origin, c.StackName)
s.Stop()
if err != nil {
if err == api.ErrStatusForbidden {
stacks, herr := api.Stacks()
if herr != nil {
return fmt.Errorf("unable to query stacks: %w", herr)
}
for _, s := range stacks {
if s.Name == c.StackName {
return err
}
}
return fmt.Errorf("bad request: unable to find stack %s", c.StackName)
}
return err
}
fmt.Printf("\nSuccess: created app '%s' with id '%d'\n", r.ApplicationName, r.ID)
return err
}
// AppsDeleteCmd handles deleting apps on Section
type AppsDeleteCmd struct {
AccountID int `required short:"a" help:"ID of account the app belongs to"`
AppID int `required short:"i" help:"ID of the app to delete"`
}
// Run executes the command
func (c *AppsDeleteCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Deleting app with id '%d'", c.AppID))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
_, err = api.ApplicationDelete(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("\nSuccess: deleted app with id '%d'\n", c.AppID)
return err
}
// AppsInitCmd creates and validates server.conf and package.json to prepare an app for deployment
type AppsInitCmd struct {
StackName string `optional default:"nodejs-basic" short:"s" help:"Name of stack to deploy. Default is nodejs-basic"`
Force bool `optional short:"f" help:"Resets deployment specific files to their default configuration"`
}
func (c *AppsInitCmd) buildServerConf() []byte {
return []byte(
`location / {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
include /etc/nginx/section.module/node.conf;
}
location ~ "/next-proxy-hop/" {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
proxy_pass http://next-hop;
}`)
}
// Run executes the command
func (c *AppsInitCmd) Run() (err error) {
var stdout bytes.Buffer
var stderr bytes.Buffer
switch c.StackName {
case "nodejs-basic":
err := c.InitializeNodeBasicApp(stdout, stderr)
if err != nil {
return fmt.Errorf("[ERROR]: init completed with error %x", err)
}
default:
log.Printf("[ERROR]: Stack name %s does not have an initialization defined\n", c.StackName)
}
return err
}
// Create package.json
func (c *AppsInitCmd) CreatePkgJSON(stdout, stderr bytes.Buffer) (err error) {
cmd := exec.Command("npm", "init", "-y")
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
return err
}
// InitializeNodeBasicApp initializes a basic node app.
func (c *AppsInitCmd) InitializeNodeBasicApp(stdout, stderr bytes.Buffer) (err error) {
if c.Force {
log.Println("[INFO] Removing old versions of server.conf and package.json")
err1 := os.Remove("package.json")
err2 := os.Remove("server.conf")
if err1 != nil || err2 != nil {
log.Println("[ERROR] unable to remove files, perhaps they do not exist?")
} else {
log.Println("[DEBUG] Files successfully removed")
}
}
log.Println("[DEBUG] Checking to see if server.conf exists")
checkServConf, err := os.Open("server.conf")
if err != nil {
log.Println("[WARN] server.conf does not exist. Creating server.conf")
f, err := os.Create("server.conf")
if err != nil {
return fmt.Errorf("error in creating a file: server.conf %w", err)
}
b := c.buildServerConf()
f.Write(b)
defer f.Close()
} else {
log.Println("[INFO] Validating server.conf")
fileinfo, err := checkServConf.Stat()
if err != nil {
return fmt.Errorf("error in finding stat of server.conf %w", err)
}
buf := make([]byte, fileinfo.Size())
_, err = checkServConf.Read(buf)
if err != nil {
return fmt.Errorf("error in size stat of server.conf %w", err)
}
fStr := string(buf)
if !strings.Contains(fStr, "location / {") {
log.Println("[WARN] default location unspecified. Edit or delete server.conf and rerun this command")
}
}
defer checkServConf.Close()
log.Println("[DEBUG] Checking to see if package.json exists")
checkPkgJSON, err := os.Open("package.json")
if err != nil {
log.Println("[WARN] package.json does not exist. Creating package.json")
err := c.CreatePkgJSON(stdout, stderr)
if err != nil {
return fmt.Errorf("there was an | Run | identifier_name |
apps.go | ) Run() (err error) {
var aids []int
if c.AccountID == 0 {
s := NewSpinner("Looking up accounts")
s.Start()
as, err := api.Accounts()
if err != nil {
return fmt.Errorf("unable to look up accounts: %w", err)
}
for _, a := range as {
aids = append(aids, a.ID)
}
s.Stop()
} else {
aids = append(aids, c.AccountID)
}
s := NewSpinner("Looking up apps")
s.Start()
apps := make(map[int][]api.App)
for _, id := range aids {
as, err := api.Applications(id)
if err != nil {
return fmt.Errorf("unable to look up applications: %w", err)
}
apps[id] = as
}
s.Stop()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Account ID", "App ID", "App Name"})
for id, as := range apps {
for _, a := range as {
r := []string{strconv.Itoa(id), strconv.Itoa(a.ID), a.ApplicationName}
table.Append(r)
}
}
table.Render()
return err
}
// AppsInfoCmd shows detailed information on an app running on Section
type AppsInfoCmd struct {
AccountID int `required short:"a"`
AppID int `required short:"i"`
}
// Run executes the command
func (c *AppsInfoCmd) Run() (err error) {
s := NewSpinner("Looking up app info")
s.Start()
app, err := api.Application(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("🌎🌏🌍\n")
fmt.Printf("App Name: %s\n", app.ApplicationName)
fmt.Printf("App ID: %d\n", app.ID)
fmt.Printf("Environment count: %d\n", len(app.Environments))
for i, env := range app.Environments {
fmt.Printf("\n-----------------\n\n")
fmt.Printf("Environment #%d: %s (ID:%d)\n\n", i+1, env.EnvironmentName, env.ID)
fmt.Printf("💬 Domains (%d total)\n", len(env.Domains))
for _, dom := range env.Domains {
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Attribute", "Value"})
table.SetAutoMergeCells(true)
r := [][]string{
[]string{"Domain name", dom.Name},
[]string{"Zone name", dom.ZoneName},
[]string{"CNAME", dom.CNAME},
[]string{"Mode", dom.Mode},
}
table.AppendBulk(r)
table.Render()
}
fmt.Println()
mod := "modules"
if len(env.Stack) == 1 {
mod = "module"
}
fmt.Printf("🥞 Stack (%d %s total)\n", len(env.Stack), mod)
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Name", "Image"})
table.SetAutoMergeCells(true)
for _, p := range env.Stack {
r := []str | ()
}
fmt.Println()
return err
}
// AppsCreateCmd handles creating apps on Section
type AppsCreateCmd struct {
AccountID int `required short:"a" help:"ID of account to create the app under"`
Hostname string `required short:"d" help:"FQDN the app can be accessed at"`
Origin string `required short:"o" help:"URL to fetch the origin"`
StackName string `required short:"s" help:"Name of stack to deploy"`
}
// Run executes the command
func (c *AppsCreateCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Creating new app %s", c.Hostname))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
r, err := api.ApplicationCreate(c.AccountID, c.Hostname, c.Origin, c.StackName)
s.Stop()
if err != nil {
if err == api.ErrStatusForbidden {
stacks, herr := api.Stacks()
if herr != nil {
return fmt.Errorf("unable to query stacks: %w", herr)
}
for _, s := range stacks {
if s.Name == c.StackName {
return err
}
}
return fmt.Errorf("bad request: unable to find stack %s", c.StackName)
}
return err
}
fmt.Printf("\nSuccess: created app '%s' with id '%d'\n", r.ApplicationName, r.ID)
return err
}
// AppsDeleteCmd handles deleting apps on Section
type AppsDeleteCmd struct {
AccountID int `required short:"a" help:"ID of account the app belongs to"`
AppID int `required short:"i" help:"ID of the app to delete"`
}
// Run executes the command
func (c *AppsDeleteCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Deleting app with id '%d'", c.AppID))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
_, err = api.ApplicationDelete(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("\nSuccess: deleted app with id '%d'\n", c.AppID)
return err
}
// AppsInitCmd creates and validates server.conf and package.json to prepare an app for deployment
type AppsInitCmd struct {
StackName string `optional default:"nodejs-basic" short:"s" help:"Name of stack to deploy. Default is nodejs-basic"`
Force bool `optional short:"f" help:"Resets deployment specific files to their default configuration"`
}
func (c *AppsInitCmd) buildServerConf() []byte {
return []byte(
`location / {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
include /etc/nginx/section.module/node.conf;
}
location ~ "/next-proxy-hop/" {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
proxy_pass http://next-hop;
}`)
}
// Run executes the command
func (c *AppsInitCmd) Run() (err error) {
var stdout bytes.Buffer
var stderr bytes.Buffer
switch c.StackName {
case "nodejs-basic":
err := c.InitializeNodeBasicApp(stdout, stderr)
if err != nil {
return fmt.Errorf("[ERROR]: init completed with error %x", err)
}
default:
log.Printf("[ERROR]: Stack name %s does not have an initialization defined\n", c.StackName)
}
return err
}
// Create package.json
func (c *AppsInitCmd) CreatePkgJSON(stdout, stderr bytes.Buffer) (err error) {
cmd := exec.Command("npm", "init", "-y")
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
return err
}
// InitializeNodeBasicApp initializes a basic node app.
func (c *AppsInitCmd) InitializeNodeBasicApp(stdout, stderr bytes.Buffer) (err error) {
if c.Force {
log.Println("[INFO] Removing old versions of server.conf and package.json")
err1 := os.Remove("package.json")
err2 := os.Remove("server.conf")
if err1 != nil || err2 != nil {
log.Println("[ERROR] unable to remove files, perhaps they do not exist?")
} else {
log.Println("[DEBUG] Files successfully removed")
}
}
log.Println("[DEBUG] Checking to see if server.conf exists")
checkServConf, err := os.Open("server.conf")
if err != nil {
log.Println("[WARN] server.conf does not exist. Creating server.conf")
f, err := os.Create("server.conf")
if err != nil {
return fmt.Errorf("error in creating a file: server.conf %w", err)
}
b := c.buildServerConf()
f.Write(b)
defer f.Close()
} else {
log.Println("[INFO] Validating server.conf")
fileinfo, err := checkServConf.Stat()
if err != nil {
return fmt.Errorf("error in finding stat of server.conf %w", err)
}
buf := make([]byte, fileinfo.Size())
_, err = checkServConf.Read(buf)
if err != nil {
return fmt.Errorf("error in size stat of server.conf %w", err)
}
fStr := string(buf)
if !strings.Contains(fStr, "location / {") {
log.Println("[WARN] default location unspecified. Edit or delete server.conf and rerun this command")
}
}
defer checkServConf.Close()
log.Println("[DEBUG] Checking to see if package.json exists")
checkPkgJSON, err := os.Open("package.json")
if err != nil {
log.Println("[WARN] package.json does not exist. Creating package.json")
err := c.CreatePkgJSON(stdout, stderr)
if err != nil {
return fmt.Errorf("there was an | ing{p.Name, p.Image}
table.Append(r)
}
table.Render | conditional_block |
apps.go |
// Run executes the command
func (c *AppsListCmd) Run() (err error) {
var aids []int
if c.AccountID == 0 {
s := NewSpinner("Looking up accounts")
s.Start()
as, err := api.Accounts()
if err != nil {
return fmt.Errorf("unable to look up accounts: %w", err)
}
for _, a := range as {
aids = append(aids, a.ID)
}
s.Stop()
} else {
aids = append(aids, c.AccountID)
}
s := NewSpinner("Looking up apps")
s.Start()
apps := make(map[int][]api.App)
for _, id := range aids {
as, err := api.Applications(id)
if err != nil {
return fmt.Errorf("unable to look up applications: %w", err)
}
apps[id] = as
}
s.Stop()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Account ID", "App ID", "App Name"})
for id, as := range apps {
for _, a := range as {
r := []string{strconv.Itoa(id), strconv.Itoa(a.ID), a.ApplicationName}
table.Append(r)
}
}
table.Render()
return err
}
// AppsInfoCmd shows detailed information on an app running on Section
type AppsInfoCmd struct {
AccountID int `required short:"a"`
AppID int `required short:"i"`
}
// Run executes the command
func (c *AppsInfoCmd) Run() (err error) {
s := NewSpinner("Looking up app info")
s.Start()
app, err := api.Application(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("🌎🌏🌍\n")
fmt.Printf("App Name: %s\n", app.ApplicationName)
fmt.Printf("App ID: %d\n", app.ID)
fmt.Printf("Environment count: %d\n", len(app.Environments))
for i, env := range app.Environments {
fmt.Printf("\n-----------------\n\n")
fmt.Printf("Environment #%d: %s (ID:%d)\n\n", i+1, env.EnvironmentName, env.ID)
fmt.Printf("💬 Domains (%d total)\n", len(env.Domains))
for _, dom := range env.Domains {
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Attribute", "Value"})
table.SetAutoMergeCells(true)
r := [][]string{
[]string{"Domain name", dom.Name},
[]string{"Zone name", dom.ZoneName},
[]string{"CNAME", dom.CNAME},
[]string{"Mode", dom.Mode},
}
table.AppendBulk(r)
table.Render()
}
fmt.Println()
mod := "modules"
if len(env.Stack) == 1 {
mod = "module"
}
fmt.Printf("🥞 Stack (%d %s total)\n", len(env.Stack), mod)
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Name", "Image"})
table.SetAutoMergeCells(true)
for _, p := range env.Stack {
r := []string{p.Name, p.Image}
table.Append(r)
}
table.Render()
}
fmt.Println()
return err
}
// AppsCreateCmd handles creating apps on Section
type AppsCreateCmd struct {
AccountID int `required short:"a" help:"ID of account to create the app under"`
Hostname string `required short:"d" help:"FQDN the app can be accessed at"`
Origin string `required short:"o" help:"URL to fetch the origin"`
StackName string `required short:"s" help:"Name of stack to deploy"`
}
// Run executes the command
func (c *AppsCreateCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Creating new app %s", c.Hostname))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
r, err := api.ApplicationCreate(c.AccountID, c.Hostname, c.Origin, c.StackName)
s.Stop()
if err != nil {
if err == api.ErrStatusForbidden {
stacks, herr := api.Stacks()
if herr != nil {
return fmt.Errorf("unable to query stacks: %w", herr)
}
for _, s := range stacks {
if s.Name == c.StackName {
return err
}
}
return fmt.Errorf("bad request: unable to find stack %s", c.StackName)
}
return err
}
fmt.Printf("\nSuccess: created app '%s' with id '%d'\n", r.ApplicationName, r.ID)
return err
}
// AppsDeleteCmd handles deleting apps on Section
type AppsDeleteCmd struct {
AccountID int `required short:"a" help:"ID of account the app belongs to"`
AppID int `required short:"i" help:"ID of the app to delete"`
}
// Run executes the command
func (c *AppsDeleteCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Deleting app with id '%d'", c.AppID))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
_, err = api.ApplicationDelete(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("\nSuccess: deleted app with id '%d'\n", c.AppID)
return err
}
// AppsInitCmd creates and validates server.conf and package.json to prepare an app for deployment
type AppsInitCmd struct {
StackName string `optional default:"nodejs-basic" short:"s" help:"Name of stack to deploy. Default is nodejs-basic"`
Force bool `optional short:"f" help:"Resets deployment specific files to their default configuration"`
}
func (c *AppsInitCmd) buildServerConf() []byte {
return []byte(
`location / {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
include /etc/nginx/section.module/node.conf;
}
location ~ "/next-proxy-hop/" {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
proxy_pass http://next-hop;
}`)
}
// Run executes the command
func (c *AppsInitCmd) Run() (err error) {
var stdout bytes.Buffer
var stderr bytes.Buffer
switch c.StackName {
case "nodejs-basic":
err := c.InitializeNodeBasicApp(stdout, stderr)
if err != nil {
return fmt.Errorf("[ERROR]: init completed with error %x", err)
}
default:
log.Printf("[ERROR]: Stack name %s does not have an initialization defined\n", c.StackName)
}
return err
}
// Create package.json
func (c *AppsInitCmd) CreatePkgJSON(stdout, stderr bytes.Buffer) (err error) {
cmd := exec.Command("npm", "init", "-y")
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
return err
}
// InitializeNodeBasicApp initializes a basic node app.
func (c *AppsInitCmd) InitializeNodeBasicApp(stdout, stderr bytes.Buffer) (err error) {
if c.Force {
log.Println("[INFO] Removing old versions of server.conf and package.json")
err1 := os.Remove("package.json")
err2 := os.Remove("server.conf")
if err1 != nil || err2 != nil {
log.Println("[ERROR] unable to remove files, perhaps they do not exist?")
} else {
log.Println("[DEBUG] Files successfully removed")
}
}
log.Println("[DEBUG] Checking to see if server.conf exists")
checkServConf, err := os.Open("server.conf")
if err != nil {
log.Println("[WARN] server.conf does not exist. Creating server.conf")
f, err := os.Create("server.conf")
if err != nil {
return fmt.Errorf("error in creating a file: server.conf %w", err)
}
b := c.buildServerConf()
f.Write(b)
defer f.Close()
} else {
log.Println("[INFO] Validating server.conf")
fileinfo, err := checkServConf.Stat()
if err != nil {
return fmt.Errorf("error in finding stat of server.conf %w", err)
}
buf := make([]byte, fileinfo.Size())
_, err = checkServConf.Read(buf)
if err != nil {
return fmt.Errorf("error in size stat of server.conf %w", err)
}
fStr := string(buf)
if !strings.Contains(fStr, "location / {") {
log.Println("[WARN] default location unspecified. Edit or delete server.conf and rerun this command")
}
}
defer checkServConf.Close()
log.Println("[DEBUG] Checking to see if package | {
t = tablewriter.NewWriter(out)
t.SetBorders(tablewriter.Border{Left: true, Top: false, Right: true, Bottom: false})
t.SetCenterSeparator("|")
t.SetAlignment(tablewriter.ALIGN_LEFT)
return t
} | identifier_body | |
apps.go | ) Run() (err error) {
var aids []int
if c.AccountID == 0 {
s := NewSpinner("Looking up accounts")
s.Start()
as, err := api.Accounts()
if err != nil {
return fmt.Errorf("unable to look up accounts: %w", err)
}
for _, a := range as {
aids = append(aids, a.ID)
}
s.Stop()
} else {
aids = append(aids, c.AccountID)
}
s := NewSpinner("Looking up apps")
s.Start()
apps := make(map[int][]api.App)
for _, id := range aids {
as, err := api.Applications(id)
if err != nil {
return fmt.Errorf("unable to look up applications: %w", err)
}
apps[id] = as
}
s.Stop()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Account ID", "App ID", "App Name"})
for id, as := range apps {
for _, a := range as {
r := []string{strconv.Itoa(id), strconv.Itoa(a.ID), a.ApplicationName}
table.Append(r)
}
}
table.Render()
return err
}
// AppsInfoCmd shows detailed information on an app running on Section
type AppsInfoCmd struct {
AccountID int `required short:"a"`
AppID int `required short:"i"`
}
// Run executes the command
func (c *AppsInfoCmd) Run() (err error) {
s := NewSpinner("Looking up app info")
s.Start()
app, err := api.Application(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("🌎🌏🌍\n")
fmt.Printf("App Name: %s\n", app.ApplicationName)
fmt.Printf("App ID: %d\n", app.ID)
fmt.Printf("Environment count: %d\n", len(app.Environments))
for i, env := range app.Environments {
fmt.Printf("\n-----------------\n\n")
fmt.Printf("Environment #%d: %s (ID:%d)\n\n", i+1, env.EnvironmentName, env.ID)
fmt.Printf("💬 Domains (%d total)\n", len(env.Domains))
for _, dom := range env.Domains {
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Attribute", "Value"})
table.SetAutoMergeCells(true)
r := [][]string{
[]string{"Domain name", dom.Name},
[]string{"Zone name", dom.ZoneName},
[]string{"CNAME", dom.CNAME},
[]string{"Mode", dom.Mode},
}
table.AppendBulk(r)
table.Render()
}
fmt.Println()
mod := "modules"
if len(env.Stack) == 1 {
mod = "module"
}
fmt.Printf("🥞 Stack (%d %s total)\n", len(env.Stack), mod)
fmt.Println()
table := NewTable(os.Stdout)
table.SetHeader([]string{"Name", "Image"})
table.SetAutoMergeCells(true)
for _, p := range env.Stack {
r := []string{p.Name, p.Image}
table.Append(r)
}
table.Render()
}
fmt.Println()
return err
}
// AppsCreateCmd handles creating apps on Section
type AppsCreateCmd struct {
AccountID int `required short:"a" help:"ID of account to create the app under"`
Hostname string `required short:"d" help:"FQDN the app can be accessed at"`
Origin string `required short:"o" help:"URL to fetch the origin"`
StackName string `required short:"s" help:"Name of stack to deploy"`
}
// Run executes the command
func (c *AppsCreateCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Creating new app %s", c.Hostname))
s.Start() | s.Stop()
if err != nil {
if err == api.ErrStatusForbidden {
stacks, herr := api.Stacks()
if herr != nil {
return fmt.Errorf("unable to query stacks: %w", herr)
}
for _, s := range stacks {
if s.Name == c.StackName {
return err
}
}
return fmt.Errorf("bad request: unable to find stack %s", c.StackName)
}
return err
}
fmt.Printf("\nSuccess: created app '%s' with id '%d'\n", r.ApplicationName, r.ID)
return err
}
// AppsDeleteCmd handles deleting apps on Section
type AppsDeleteCmd struct {
AccountID int `required short:"a" help:"ID of account the app belongs to"`
AppID int `required short:"i" help:"ID of the app to delete"`
}
// Run executes the command
func (c *AppsDeleteCmd) Run() (err error) {
s := NewSpinner(fmt.Sprintf("Deleting app with id '%d'", c.AppID))
s.Start()
api.Timeout = 120 * time.Second // this specific request can take a long time
_, err = api.ApplicationDelete(c.AccountID, c.AppID)
s.Stop()
if err != nil {
return err
}
fmt.Printf("\nSuccess: deleted app with id '%d'\n", c.AppID)
return err
}
// AppsInitCmd creates and validates server.conf and package.json to prepare an app for deployment
type AppsInitCmd struct {
StackName string `optional default:"nodejs-basic" short:"s" help:"Name of stack to deploy. Default is nodejs-basic"`
Force bool `optional short:"f" help:"Resets deployment specific files to their default configuration"`
}
func (c *AppsInitCmd) buildServerConf() []byte {
return []byte(
`location / {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
include /etc/nginx/section.module/node.conf;
}
location ~ "/next-proxy-hop/" {
proxy_set_header X-Forwarded-For $http_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $http_x_forwarded_proto;
proxy_set_header Host $host;
proxy_pass http://next-hop;
}`)
}
// Run executes the command
func (c *AppsInitCmd) Run() (err error) {
var stdout bytes.Buffer
var stderr bytes.Buffer
switch c.StackName {
case "nodejs-basic":
err := c.InitializeNodeBasicApp(stdout, stderr)
if err != nil {
return fmt.Errorf("[ERROR]: init completed with error %x", err)
}
default:
log.Printf("[ERROR]: Stack name %s does not have an initialization defined\n", c.StackName)
}
return err
}
// Create package.json
func (c *AppsInitCmd) CreatePkgJSON(stdout, stderr bytes.Buffer) (err error) {
cmd := exec.Command("npm", "init", "-y")
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err = cmd.Run()
return err
}
// InitializeNodeBasicApp initializes a basic node app.
func (c *AppsInitCmd) InitializeNodeBasicApp(stdout, stderr bytes.Buffer) (err error) {
if c.Force {
log.Println("[INFO] Removing old versions of server.conf and package.json")
err1 := os.Remove("package.json")
err2 := os.Remove("server.conf")
if err1 != nil || err2 != nil {
log.Println("[ERROR] unable to remove files, perhaps they do not exist?")
} else {
log.Println("[DEBUG] Files successfully removed")
}
}
log.Println("[DEBUG] Checking to see if server.conf exists")
checkServConf, err := os.Open("server.conf")
if err != nil {
log.Println("[WARN] server.conf does not exist. Creating server.conf")
f, err := os.Create("server.conf")
if err != nil {
return fmt.Errorf("error in creating a file: server.conf %w", err)
}
b := c.buildServerConf()
f.Write(b)
defer f.Close()
} else {
log.Println("[INFO] Validating server.conf")
fileinfo, err := checkServConf.Stat()
if err != nil {
return fmt.Errorf("error in finding stat of server.conf %w", err)
}
buf := make([]byte, fileinfo.Size())
_, err = checkServConf.Read(buf)
if err != nil {
return fmt.Errorf("error in size stat of server.conf %w", err)
}
fStr := string(buf)
if !strings.Contains(fStr, "location / {") {
log.Println("[WARN] default location unspecified. Edit or delete server.conf and rerun this command")
}
}
defer checkServConf.Close()
log.Println("[DEBUG] Checking to see if package.json exists")
checkPkgJSON, err := os.Open("package.json")
if err != nil {
log.Println("[WARN] package.json does not exist. Creating package.json")
err := c.CreatePkgJSON(stdout, stderr)
if err != nil {
return fmt.Errorf("there was an |
api.Timeout = 120 * time.Second // this specific request can take a long time
r, err := api.ApplicationCreate(c.AccountID, c.Hostname, c.Origin, c.StackName) | random_line_split |
Week_05.py | can return data as a result.
"""
# writing a function
def printInfo(): # defines what the function does when called
print("Name: John Smith") # calls the function to run
print("Age: 45") # calls the function again
printInfo()
printInfo()
# Function Stages
"""
There are two stages: function definition and function call.
Function definition is where you define the function name, any parameters it's supposed to accept,
and what it's supposed to do in the block of code associated with it.
The second stage is known as the function call. Functions will never run until called,
so you can define as many functions as you’d like, but if you never call one of them, then
nothing will happen. When you call a function, it will run the block of code within the
definition
"""
# UDF vs. Built-in
"""
Built-in functions are included in Python to serve a specific purpose to help build applications.
UDFs are user-defined functions.
"""
# performing a calculation in a function
def calc():
x, y = 5, 10
print(x+y)
calc() # will run the block of code within calc and output 15
# Exercises
"""
1. Print Name: Define a function called myName, and have it print out your name
when called.
"""
# solution
def myName():
name = "Nick"
print(name)
myName()
"""
2. Pizza Toppings: Define a function that prints out all your favorite pizza toppings
called pizzaToppings. Call the function three times.
"""
# solution
def pizzaToppings():
topping1, topping2, topping3 = "Cheese,", "Pepperoni,", "Chicken"
print(topping1, topping2, topping3)
pizzaToppings()
pizzaToppings()
pizzaToppings()
# Parameters
"""
Parameters are temporary variables declared on the function definition. To call a function with
different values, you need to use parameters. This is an arbitrary variable name that you use to reference the value within the function block; however, you usually want it to
be relevent to the data that you're working with. When calling the function, you would pass in the necessary value to run the block of code with.
"""
# Passing a Single Parameter
def printName(full_name):
print("Your name is: {}".format(full_name))
printName("John Smith")
printName("Amanda")
# Multiple parameters
# passing multiple parameters into a function
def addNums(num1, num2):
result = num1+num2
print("{} + {} = {}".format(num1, num2, result))
addNums(5, 8)
addNums(3.5, 5.5)
# passing a list
# using a function to square all information
numbers1 = [2, 4, 5, 10]
numbers2 = [1, 3, 6]
# def squares(nums):
# for num in nums:
# print(nums**2)
# squares(numbers1)
# squares(numbers2)
# Default Parameters
"""
A parameter can be associated with a default value. Take the value of pi for instance, it will always be 3.14,
so we can set a parameter called pi to that exact value to allow us to call the function with an already defined value for pi.
"""
# setting default parameter values
def calcArea(r, pi=3.14):
area = pi*(r**2)
print("Area: {}".format(area))
calcArea(2) # assuming radius is the value of 2
"""
Note: Default parameters must always go after non-default parameters.
"""
# Making Parameters Optional
"""
Sometimes you need to make functions that take optional arguments. The best example
is always middle names; some people have them, and some don’t. If we wanted to write
a function that would print out properly for both situations, we would need to make the
middle name an optional parameter. We do this by assigning an empty string value as
the default:
"""
# setting default parameter values
def printName(first, last, middle=""):
if middle:
print("{} {} {}".format(first, middle, last))
else:
print("{} {}".format(first, last))
printName("John", "Smith")
printName("John", "Smith", "Paul") # will output with middle name
# Keep in mind the order of our parameters! Parameters must line up from left to right according to the function definition.
# Named Parameter Assignment
"""
During the function call, you can explicity assign values into parameter names. This is useful
when you don’t want to mix up the order of values being passed in, as they work from left
to right by default. You can use parameter names to assign values for every parameter if
you choose, but it’s not necessary most of the time. Let’s check out an example:
"""
# explicity assigning values to parameters by referencing the name
def addNums(num1, num2):
print(num2)
print(num1)
addNums(5, num2=2.5)
# *args
"""
The use of *args allows you to pass a variable number of arguments into a function. This
allows you to make functions more modular. The magic isn’t the “args” keyword here
though; it’s really the unary operator ( * ) that allows us to perform this feature. You could
theoretically replace the word args with anyone, like “ *data”, and it would still work.
However, args is the default and general standard throughout the industry.
"""
# using args parameter to take in a tuple of arbitrary value
def outputData(name, *args):
print(type(args))
for arg in args:
print(arg)
outputData("John Smith", 5, True, "Jess")
# **kwargs
"""
Like args, kwargs allows us to take in an arbitrary number of values in a function;
however, it works as a dictionary with keyword arguments instead. Keyword arguments
are values passed in with keys, which allow us to access them easily within the function
block. Again, the magic here is in the two unary operators ( ** ) not the keyword of
kwargs. Let’s check it out:
"""
# using kwargs parameter to take in a dictionary of arbitrary value
def outputData(**kwargs):
print(type(kwargs))
print(kwargs["name"])
print(kwargs["num"])
outputData(name="John Smith", num=5, b=True)
# Exercises
"""
1. User Input: Ask the user to input a word, and pass that word into a function
that checks if the word starts with an uppercase. If it does output “True”,
otherwise “False”.
"""
# solution
def checkCaps(name):
if name[0].isupper() == True:
print("True")
else:
print("Fal | input("Enter your name")
checkCaps(name)
"""
2. No Name: Define a function that takes in two arguments, first_name and last_
name, and makes both optional. If no values are passed into the parameters, it
should output “No name passed in”; otherwise, it should print out the name.
"""
# solution
# def checkName(first_name, last_name):
# print("{} {}".format(first_name, last_name))
# checkName()
# Return Statement - is used to send info back to where the function call occured.
# using return keyword to return the sum of two numbers
def addNums(num1, num2):
return num1+num2
num = addNums(5.5, 4.5) # saves returned value into num
print(num)
print(addNums(10, 10)) # doesn't save returned value
# Ternary Operator
"""
A ternary operator is a shorthand python branching statement.
These operations can be used to assign values into a variable, or in this case, deciding what the return from a function
"""
# shorthand syntax using a ternary operator
def searchList(aList, el):
return True if el in aList else False
result = searchList(["one", 2, "three"], 2) # result = True
print(result)
# Exercises
"""
Full Name: Create a function that takes in a first and last name and returns the
two names joined together.
"""
# solution
def joinNames(firstName, lastName):
return firstName + lastName
firstName, lastName = "Nick ", "Mwangemi"
print(joinNames(firstName, lastName))
"""
2. User Input: Within a function, ask for user input. Have this function return that
input to be stored in a variable outside of the function. Then print out the input.
"""
# solution
def userInput(userInput):
faveSport = input("What's your favourite sport?")
return faveSport
faveSport = userInput("rugby")
print(faveSport)
# Scope -deals with the accessibility of variables declared within a program
# Types: global, function, class
# Global - when you declare a variable to be accessible to an entire file or application
# Function scope is in reference to variables being declared and accessible only withi functions
# Global Scope Access - accessible to the rest of the file
# where global variables can be accessed
# number = 5
# def scopeTest():
# number += 1 # not accessible due to function level scope
# scopeTest()
"""
Note: When passed in, it only passes the value, not the variable
"""
# Handling Function Scope
"""
When dealing with variables declared in a function, you generally won't need to | se")
name = | conditional_block |
Week_05.py | can return data as a result.
"""
# writing a function
def printInfo(): # defines what the function does when called
print("Name: John Smith") # calls the function to run
print("Age: 45") # calls the function again
printInfo()
printInfo()
# Function Stages
"""
There are two stages: function definition and function call.
Function definition is where you define the function name, any parameters it's supposed to accept,
and what it's supposed to do in the block of code associated with it.
The second stage is known as the function call. Functions will never run until called,
so you can define as many functions as you’d like, but if you never call one of them, then
nothing will happen. When you call a function, it will run the block of code within the
definition
"""
# UDF vs. Built-in
"""
Built-in functions are included in Python to serve a specific purpose to help build applications.
UDFs are user-defined functions.
"""
# performing a calculation in a function
def calc():
x, y = 5, 10
print(x+y)
calc() # will run the block of code within calc and output 15
# Exercises
"""
1. Print Name: Define a function called myName, and have it print out your name
when called.
"""
# solution
def myName():
name = "Nick"
print(name)
myName()
"""
2. Pizza Toppings: Define a function that prints out all your favorite pizza toppings
called pizzaToppings. Call the function three times.
"""
# solution
def pizzaToppings():
topping1, topping2, topping3 = "Cheese,", "Pepperoni,", "Chicken"
print(topping1, topping2, topping3)
pizzaToppings()
pizzaToppings()
pizzaToppings()
# Parameters
"""
Parameters are temporary variables declared on the function definition. To call a function with
different values, you need to use parameters. This is an arbitrary variable name that you use to reference the value within the function block; however, you usually want it to
be relevent to the data that you're working with. When calling the function, you would pass in the necessary value to run the block of code with.
"""
# Passing a Single Parameter
def printName(full_name):
print("Your name is: {}".format(full_name))
printName("John Smith")
printName("Amanda")
# Multiple parameters
# passing multiple parameters into a function
def addNums(num1, num2):
result = num1+num2
print("{} + {} = {}".format(num1, num2, result))
addNums(5, 8)
addNums(3.5, 5.5)
# passing a list
# using a function to square all information
numbers1 = [2, 4, 5, 10]
numbers2 = [1, 3, 6]
# def squares(nums):
# for num in nums:
# print(nums**2)
# squares(numbers1)
# squares(numbers2)
# Default Parameters
"""
A parameter can be associated with a default value. Take the value of pi for instance, it will always be 3.14,
so we can set a parameter called pi to that exact value to allow us to call the function with an already defined value for pi.
"""
# setting default parameter values
def calcArea(r, pi=3.14):
area = pi*(r**2)
print("Area: {}".format(area))
calcArea(2) # assuming radius is the value of 2
"""
Note: Default parameters must always go after non-default parameters.
"""
# Making Parameters Optional
"""
Sometimes you need to make functions that take optional arguments. The best example
is always middle names; some people have them, and some don’t. If we wanted to write
a function that would print out properly for both situations, we would need to make the
middle name an optional parameter. We do this by assigning an empty string value as
the default:
"""
# setting default parameter values
def printName(first, last, middle=""):
if middle:
print("{} {} {}".format(first, middle, last))
else:
print("{} {}".format(first, last))
printName("John", "Smith")
printName("John", "Smith", "Paul") # will output with middle name
# Keep in mind the order of our parameters! Parameters must line up from left to right according to the function definition.
# Named Parameter Assignment
"""
During the function call, you can explicity assign values into parameter names. This is useful
when you don’t want to mix up the order of values being passed in, as they work from left
to right by default. You can use parameter names to assign values for every parameter if
you choose, but it’s not necessary most of the time. Let’s check out an example:
"""
# explicity assigning values to parameters by referencing the name
def addNums(num1, num2):
print(num2)
prin | .5)
# *args
"""
The use of *args allows you to pass a variable number of arguments into a function. This
allows you to make functions more modular. The magic isn’t the “args” keyword here
though; it’s really the unary operator ( * ) that allows us to perform this feature. You could
theoretically replace the word args with anyone, like “ *data”, and it would still work.
However, args is the default and general standard throughout the industry.
"""
# using args parameter to take in a tuple of arbitrary value
def outputData(name, *args):
print(type(args))
for arg in args:
print(arg)
outputData("John Smith", 5, True, "Jess")
# **kwargs
"""
Like args, kwargs allows us to take in an arbitrary number of values in a function;
however, it works as a dictionary with keyword arguments instead. Keyword arguments
are values passed in with keys, which allow us to access them easily within the function
block. Again, the magic here is in the two unary operators ( ** ) not the keyword of
kwargs. Let’s check it out:
"""
# using kwargs parameter to take in a dictionary of arbitrary value
def outputData(**kwargs):
print(type(kwargs))
print(kwargs["name"])
print(kwargs["num"])
outputData(name="John Smith", num=5, b=True)
# Exercises
"""
1. User Input: Ask the user to input a word, and pass that word into a function
that checks if the word starts with an uppercase. If it does output “True”,
otherwise “False”.
"""
# solution
def checkCaps(name):
if name[0].isupper() == True:
print("True")
else:
print("False")
name = input("Enter your name")
checkCaps(name)
"""
2. No Name: Define a function that takes in two arguments, first_name and last_
name, and makes both optional. If no values are passed into the parameters, it
should output “No name passed in”; otherwise, it should print out the name.
"""
# solution
# def checkName(first_name, last_name):
# print("{} {}".format(first_name, last_name))
# checkName()
# Return Statement - is used to send info back to where the function call occured.
# using return keyword to return the sum of two numbers
def addNums(num1, num2):
return num1+num2
num = addNums(5.5, 4.5) # saves returned value into num
print(num)
print(addNums(10, 10)) # doesn't save returned value
# Ternary Operator
"""
A ternary operator is a shorthand python branching statement.
These operations can be used to assign values into a variable, or in this case, deciding what the return from a function
"""
# shorthand syntax using a ternary operator
def searchList(aList, el):
return True if el in aList else False
result = searchList(["one", 2, "three"], 2) # result = True
print(result)
# Exercises
"""
Full Name: Create a function that takes in a first and last name and returns the
two names joined together.
"""
# solution
def joinNames(firstName, lastName):
return firstName + lastName
firstName, lastName = "Nick ", "Mwangemi"
print(joinNames(firstName, lastName))
"""
2. User Input: Within a function, ask for user input. Have this function return that
input to be stored in a variable outside of the function. Then print out the input.
"""
# solution
def userInput(userInput):
faveSport = input("What's your favourite sport?")
return faveSport
faveSport = userInput("rugby")
print(faveSport)
# Scope -deals with the accessibility of variables declared within a program
# Types: global, function, class
# Global - when you declare a variable to be accessible to an entire file or application
# Function scope is in reference to variables being declared and accessible only withi functions
# Global Scope Access - accessible to the rest of the file
# where global variables can be accessed
# number = 5
# def scopeTest():
# number += 1 # not accessible due to function level scope
# scopeTest()
"""
Note: When passed in, it only passes the value, not the variable
"""
# Handling Function Scope
"""
When dealing with variables declared in a function, you generally won't need to | t(num1)
addNums(5, num2=2 | identifier_body |
Week_05.py | can return data as a result.
"""
# writing a function
def printInfo(): # defines what the function does when called
print("Name: John Smith") # calls the function to run
print("Age: 45") # calls the function again
printInfo()
printInfo()
# Function Stages
"""
There are two stages: function definition and function call.
Function definition is where you define the function name, any parameters it's supposed to accept,
and what it's supposed to do in the block of code associated with it.
The second stage is known as the function call. Functions will never run until called,
so you can define as many functions as you’d like, but if you never call one of them, then
nothing will happen. When you call a function, it will run the block of code within the
definition
"""
# UDF vs. Built-in
"""
Built-in functions are included in Python to serve a specific purpose to help build applications.
UDFs are user-defined functions.
"""
# performing a calculation in a function
def calc():
x, y = 5, 10
print(x+y)
calc() # will run the block of code within calc and output 15
# Exercises
"""
1. Print Name: Define a function called myName, and have it print out your name
when called.
"""
# solution
def myName():
name = "Nick"
print(name)
myName()
"""
2. Pizza Toppings: Define a function that prints out all your favorite pizza toppings
called pizzaToppings. Call the function three times.
"""
# solution
def pizzaToppings():
topping1, topping2, topping3 = "Cheese,", "Pepperoni,", "Chicken"
print(topping1, topping2, topping3)
pizzaToppings()
pizzaToppings()
pizzaToppings()
# Parameters
"""
Parameters are temporary variables declared on the function definition. To call a function with
different values, you need to use parameters. This is an arbitrary variable name that you use to reference the value within the function block; however, you usually want it to
be relevent to the data that you're working with. When calling the function, you would pass in the necessary value to run the block of code with.
"""
# Passing a Single Parameter
def printName(full_name):
print("Your name is: {}".format(full_name))
printName("John Smith")
printName("Amanda")
# Multiple parameters
# passing multiple parameters into a function
def addNums(num1, num2):
result = num1+num2
print("{} + {} = {}".format(num1, num2, result))
addNums(5, 8)
addNums(3.5, 5.5)
# passing a list
# using a function to square all information
numbers1 = [2, 4, 5, 10]
numbers2 = [1, 3, 6]
# def squares(nums):
# for num in nums:
# print(nums**2)
# squares(numbers1)
# squares(numbers2)
# Default Parameters
"""
A parameter can be associated with a default value. Take the value of pi for instance, it will always be 3.14,
so we can set a parameter called pi to that exact value to allow us to call the function with an already defined value for pi.
"""
# setting default parameter values
def calcArea(r, pi=3.14):
area = pi*(r**2)
print("Area: {}".format(area))
calcArea(2) # assuming radius is the value of 2
"""
Note: Default parameters must always go after non-default parameters.
"""
# Making Parameters Optional
"""
Sometimes you need to make functions that take optional arguments. The best example
is always middle names; some people have them, and some don’t. If we wanted to write
a function that would print out properly for both situations, we would need to make the
middle name an optional parameter. We do this by assigning an empty string value as
the default:
"""
# setting default parameter values
def printName(first, last, middle=""):
if middle:
print("{} {} {}".format(first, middle, last))
else:
print("{} {}".format(first, last))
printName("John", "Smith")
printName("John", "Smith", "Paul") # will output with middle name
# Keep in mind the order of our parameters! Parameters must line up from left to right according to the function definition.
# Named Parameter Assignment
"""
During the function call, you can explicity assign values into parameter names. This is useful
when you don’t want to mix up the order of values being passed in, as they work from left
to right by default. You can use parameter names to assign values for every parameter if
you choose, but it’s not necessary most of the time. Let’s check out an example:
"""
# explicity assigning values to parameters by referencing the name
def addNums(num1, num2):
print(num2)
print(num1)
addNums(5, num2=2.5)
# *args
"""
The use of *args allows you to pass a variable number of arguments into a function. This
allows you to make functions more modular. The magic isn’t the “args” keyword here
though; it’s really the unary operator ( * ) that allows us to perform this feature. You could
theoretically replace the word args with anyone, like “ *data”, and it would still work.
However, args is the default and general standard throughout the industry.
"""
# using args parameter to take in a tuple of arbitrary value
|
outputData("John Smith", 5, True, "Jess")
# **kwargs
"""
Like args, kwargs allows us to take in an arbitrary number of values in a function;
however, it works as a dictionary with keyword arguments instead. Keyword arguments
are values passed in with keys, which allow us to access them easily within the function
block. Again, the magic here is in the two unary operators ( ** ) not the keyword of
kwargs. Let’s check it out:
"""
# using kwargs parameter to take in a dictionary of arbitrary value
def outputData(**kwargs):
print(type(kwargs))
print(kwargs["name"])
print(kwargs["num"])
outputData(name="John Smith", num=5, b=True)
# Exercises
"""
1. User Input: Ask the user to input a word, and pass that word into a function
that checks if the word starts with an uppercase. If it does output “True”,
otherwise “False”.
"""
# solution
def checkCaps(name):
if name[0].isupper() == True:
print("True")
else:
print("False")
name = input("Enter your name")
checkCaps(name)
"""
2. No Name: Define a function that takes in two arguments, first_name and last_
name, and makes both optional. If no values are passed into the parameters, it
should output “No name passed in”; otherwise, it should print out the name.
"""
# solution
# def checkName(first_name, last_name):
# print("{} {}".format(first_name, last_name))
# checkName()
# Return Statement - is used to send info back to where the function call occured.
# using return keyword to return the sum of two numbers
def addNums(num1, num2):
return num1+num2
num = addNums(5.5, 4.5) # saves returned value into num
print(num)
print(addNums(10, 10)) # doesn't save returned value
# Ternary Operator
"""
A ternary operator is a shorthand python branching statement.
These operations can be used to assign values into a variable, or in this case, deciding what the return from a function
"""
# shorthand syntax using a ternary operator
def searchList(aList, el):
return True if el in aList else False
result = searchList(["one", 2, "three"], 2) # result = True
print(result)
# Exercises
"""
Full Name: Create a function that takes in a first and last name and returns the
two names joined together.
"""
# solution
def joinNames(firstName, lastName):
return firstName + lastName
firstName, lastName = "Nick ", "Mwangemi"
print(joinNames(firstName, lastName))
"""
2. User Input: Within a function, ask for user input. Have this function return that
input to be stored in a variable outside of the function. Then print out the input.
"""
# solution
def userInput(userInput):
faveSport = input("What's your favourite sport?")
return faveSport
faveSport = userInput("rugby")
print(faveSport)
# Scope -deals with the accessibility of variables declared within a program
# Types: global, function, class
# Global - when you declare a variable to be accessible to an entire file or application
# Function scope is in reference to variables being declared and accessible only withi functions
# Global Scope Access - accessible to the rest of the file
# where global variables can be accessed
# number = 5
# def scopeTest():
# number += 1 # not accessible due to function level scope
# scopeTest()
"""
Note: When passed in, it only passes the value, not the variable
"""
# Handling Function Scope
"""
When dealing with variables declared in a function, you generally won't need to | def outputData(name, *args):
print(type(args))
for arg in args:
print(arg) | random_line_split |
Week_05.py | can return data as a result.
"""
# writing a function
def printInfo(): # defines what the function does when called
print("Name: John Smith") # calls the function to run
print("Age: 45") # calls the function again
printInfo()
printInfo()
# Function Stages
"""
There are two stages: function definition and function call.
Function definition is where you define the function name, any parameters it's supposed to accept,
and what it's supposed to do in the block of code associated with it.
The second stage is known as the function call. Functions will never run until called,
so you can define as many functions as you’d like, but if you never call one of them, then
nothing will happen. When you call a function, it will run the block of code within the
definition
"""
# UDF vs. Built-in
"""
Built-in functions are included in Python to serve a specific purpose to help build applications.
UDFs are user-defined functions.
"""
# performing a calculation in a function
def calc():
x, y = 5, 10
print(x+y)
calc() # will run the block of code within calc and output 15
# Exercises
"""
1. Print Name: Define a function called myName, and have it print out your name
when called.
"""
# solution
def myName():
name = "Nick"
print(name)
myName()
"""
2. Pizza Toppings: Define a function that prints out all your favorite pizza toppings
called pizzaToppings. Call the function three times.
"""
# solution
def pizzaToppings():
topping1, topping2, topping3 = "Cheese,", "Pepperoni,", "Chicken"
print(topping1, topping2, topping3)
pizzaToppings()
pizzaToppings()
pizzaToppings()
# Parameters
"""
Parameters are temporary variables declared on the function definition. To call a function with
different values, you need to use parameters. This is an arbitrary variable name that you use to reference the value within the function block; however, you usually want it to
be relevent to the data that you're working with. When calling the function, you would pass in the necessary value to run the block of code with.
"""
# Passing a Single Parameter
def printName(fu |
print("Your name is: {}".format(full_name))
printName("John Smith")
printName("Amanda")
# Multiple parameters
# passing multiple parameters into a function
def addNums(num1, num2):
result = num1+num2
print("{} + {} = {}".format(num1, num2, result))
addNums(5, 8)
addNums(3.5, 5.5)
# passing a list
# using a function to square all information
numbers1 = [2, 4, 5, 10]
numbers2 = [1, 3, 6]
# def squares(nums):
# for num in nums:
# print(nums**2)
# squares(numbers1)
# squares(numbers2)
# Default Parameters
"""
A parameter can be associated with a default value. Take the value of pi for instance, it will always be 3.14,
so we can set a parameter called pi to that exact value to allow us to call the function with an already defined value for pi.
"""
# setting default parameter values
def calcArea(r, pi=3.14):
area = pi*(r**2)
print("Area: {}".format(area))
calcArea(2) # assuming radius is the value of 2
"""
Note: Default parameters must always go after non-default parameters.
"""
# Making Parameters Optional
"""
Sometimes you need to make functions that take optional arguments. The best example
is always middle names; some people have them, and some don’t. If we wanted to write
a function that would print out properly for both situations, we would need to make the
middle name an optional parameter. We do this by assigning an empty string value as
the default:
"""
# setting default parameter values
def printName(first, last, middle=""):
if middle:
print("{} {} {}".format(first, middle, last))
else:
print("{} {}".format(first, last))
printName("John", "Smith")
printName("John", "Smith", "Paul") # will output with middle name
# Keep in mind the order of our parameters! Parameters must line up from left to right according to the function definition.
# Named Parameter Assignment
"""
During the function call, you can explicity assign values into parameter names. This is useful
when you don’t want to mix up the order of values being passed in, as they work from left
to right by default. You can use parameter names to assign values for every parameter if
you choose, but it’s not necessary most of the time. Let’s check out an example:
"""
# explicity assigning values to parameters by referencing the name
def addNums(num1, num2):
print(num2)
print(num1)
addNums(5, num2=2.5)
# *args
"""
The use of *args allows you to pass a variable number of arguments into a function. This
allows you to make functions more modular. The magic isn’t the “args” keyword here
though; it’s really the unary operator ( * ) that allows us to perform this feature. You could
theoretically replace the word args with anyone, like “ *data”, and it would still work.
However, args is the default and general standard throughout the industry.
"""
# using args parameter to take in a tuple of arbitrary value
def outputData(name, *args):
print(type(args))
for arg in args:
print(arg)
outputData("John Smith", 5, True, "Jess")
# **kwargs
"""
Like args, kwargs allows us to take in an arbitrary number of values in a function;
however, it works as a dictionary with keyword arguments instead. Keyword arguments
are values passed in with keys, which allow us to access them easily within the function
block. Again, the magic here is in the two unary operators ( ** ) not the keyword of
kwargs. Let’s check it out:
"""
# using kwargs parameter to take in a dictionary of arbitrary value
def outputData(**kwargs):
print(type(kwargs))
print(kwargs["name"])
print(kwargs["num"])
outputData(name="John Smith", num=5, b=True)
# Exercises
"""
1. User Input: Ask the user to input a word, and pass that word into a function
that checks if the word starts with an uppercase. If it does output “True”,
otherwise “False”.
"""
# solution
def checkCaps(name):
if name[0].isupper() == True:
print("True")
else:
print("False")
name = input("Enter your name")
checkCaps(name)
"""
2. No Name: Define a function that takes in two arguments, first_name and last_
name, and makes both optional. If no values are passed into the parameters, it
should output “No name passed in”; otherwise, it should print out the name.
"""
# solution
# def checkName(first_name, last_name):
# print("{} {}".format(first_name, last_name))
# checkName()
# Return Statement - is used to send info back to where the function call occured.
# using return keyword to return the sum of two numbers
def addNums(num1, num2):
return num1+num2
num = addNums(5.5, 4.5) # saves returned value into num
print(num)
print(addNums(10, 10)) # doesn't save returned value
# Ternary Operator
"""
A ternary operator is a shorthand python branching statement.
These operations can be used to assign values into a variable, or in this case, deciding what the return from a function
"""
# shorthand syntax using a ternary operator
def searchList(aList, el):
return True if el in aList else False
result = searchList(["one", 2, "three"], 2) # result = True
print(result)
# Exercises
"""
Full Name: Create a function that takes in a first and last name and returns the
two names joined together.
"""
# solution
def joinNames(firstName, lastName):
return firstName + lastName
firstName, lastName = "Nick ", "Mwangemi"
print(joinNames(firstName, lastName))
"""
2. User Input: Within a function, ask for user input. Have this function return that
input to be stored in a variable outside of the function. Then print out the input.
"""
# solution
def userInput(userInput):
faveSport = input("What's your favourite sport?")
return faveSport
faveSport = userInput("rugby")
print(faveSport)
# Scope -deals with the accessibility of variables declared within a program
# Types: global, function, class
# Global - when you declare a variable to be accessible to an entire file or application
# Function scope is in reference to variables being declared and accessible only withi functions
# Global Scope Access - accessible to the rest of the file
# where global variables can be accessed
# number = 5
# def scopeTest():
# number += 1 # not accessible due to function level scope
# scopeTest()
"""
Note: When passed in, it only passes the value, not the variable
"""
# Handling Function Scope
"""
When dealing with variables declared in a function, you generally won't | ll_name): | identifier_name |
controller.go | ", id)
nfsGaneshaConfig := `
EXPORT {
Export_Id = ` + idStr + `;
Path = /` + path + `;
Pseudo = /` + path + `;
Protocols = 4;
Transports = TCP;
Sectype = sys;
Access_Type = ` + accessType + `;
Squash = ` + s.ToLower(squash) + `;
FSAL {
Name = VFS;
}
}`
return nfsGaneshaConfig
}
func createGaneshaConfig(spec *nfsv1alpha1.NFSServerSpec) string {
serverConfig := getServerConfig(spec.Exports)
exportsList := make([]string, 0)
id := 10
for claimName, claimConfig := range serverConfig {
exportsList = append(exportsList, createGaneshaExport(id, claimName, claimConfig["accessMode"], claimConfig["squash"]))
id++
}
// fsid_device parameter is important as in case of an overlayfs there is a chance that the fsid of the mounted share is same as that of the fsid of "/"
// so setting this to true uses device number as fsid
// related issue https://github.com/nfs-ganesha/nfs-ganesha/issues/140
exportsList = append(exportsList, `NFS_Core_Param
{
fsid_device = true;
}`)
nfsGaneshaConfig := s.Join(exportsList, "\n")
return nfsGaneshaConfig
}
func (c *Controller) createNFSConfigMap(nfsServer *nfsServer) error {
nfsGaneshaConfig := createGaneshaConfig(&nfsServer.spec)
configMap := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: nfsConfigMapName,
Namespace: nfsServer.namespace,
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
Labels: createAppLabels(),
},
Data: map[string]string{
nfsConfigMapName: nfsGaneshaConfig,
},
}
_, err := c.context.Clientset.CoreV1().ConfigMaps(nfsServer.namespace).Create(configMap)
if err != nil {
return err
}
return nil
}
func getPVCNameList(spec *nfsv1alpha1.NFSServerSpec) []string {
exports := spec.Exports
pvcNameList := make([]string, 0)
for _, export := range exports {
claimName := export.PersistentVolumeClaim.ClaimName
if claimName != "" {
pvcNameList = append(pvcNameList, claimName)
}
}
return pvcNameList
}
func createPVCSpecList(spec *nfsv1alpha1.NFSServerSpec) []v1.Volume {
pvcSpecList := make([]v1.Volume, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
pvcSpecList = append(pvcSpecList, v1.Volume{
Name: claimName,
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: claimName,
},
},
})
}
configMapSrc := &v1.ConfigMapVolumeSource{
Items: []v1.KeyToPath{
{
Key: nfsConfigMapName,
Path: nfsConfigMapName,
},
},
}
configMapSrc.Name = nfsConfigMapName
configMapVol := v1.Volume{
Name: nfsConfigMapName,
VolumeSource: v1.VolumeSource{
ConfigMap: configMapSrc,
},
}
pvcSpecList = append(pvcSpecList, configMapVol)
return pvcSpecList
}
func createVolumeMountList(spec *nfsv1alpha1.NFSServerSpec) []v1.VolumeMount {
volumeMountList := make([]v1.VolumeMount, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
volumeMountList = append(volumeMountList, v1.VolumeMount{
Name: claimName,
MountPath: "/" + claimName,
})
}
configMapVolMount := v1.VolumeMount{
Name: nfsConfigMapName,
MountPath: nfsConfigMapPath,
}
volumeMountList = append(volumeMountList, configMapVolMount)
return volumeMountList
}
func (c *Controller) createNfsPodSpec(nfsServer *nfsServer) v1.PodTemplateSpec {
nfsPodSpec := v1.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Name: nfsServer.name,
Namespace: nfsServer.namespace,
Labels: createAppLabels(),
},
Spec: v1.PodSpec{
Containers: []v1.Container{
{
Name: nfsServer.name,
Image: c.containerImage,
Command: []string{"/start.sh"},
Ports: []v1.ContainerPort{
{
Name: "nfs-port",
ContainerPort: int32(nfsPort),
},
{
Name: "rpc-port",
ContainerPort: int32(rpcPort),
},
},
VolumeMounts: createVolumeMountList(&nfsServer.spec),
SecurityContext: &v1.SecurityContext{
Capabilities: &v1.Capabilities{
Add: []v1.Capability{
"SYS_ADMIN",
"DAC_READ_SEARCH",
},
},
},
},
},
Volumes: createPVCSpecList(&nfsServer.spec),
},
}
return nfsPodSpec
}
func (c *Controller) createNfsStatefulSet(nfsServer *nfsServer, replicas int32) error {
appsClient := c.context.Clientset.AppsV1beta1()
nfsPodSpec := c.createNfsPodSpec(nfsServer)
statefulSet := v1beta1.StatefulSet{
ObjectMeta: metav1.ObjectMeta{
Name: nfsServer.name,
Namespace: nfsServer.namespace,
Labels: createAppLabels(),
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
},
Spec: v1beta1.StatefulSetSpec{
Replicas: &replicas,
Selector: &metav1.LabelSelector{
MatchLabels: createAppLabels(),
},
Template: nfsPodSpec,
ServiceName: nfsServer.name,
},
}
if _, err := appsClient.StatefulSets(nfsServer.namespace).Create(&statefulSet); err != nil {
if !errors.IsAlreadyExists(err) {
return err
}
logger.Infof("stateful set %s already exists in namespace %s", statefulSet.Name, statefulSet.Namespace)
} else {
logger.Infof("stateful set %s created in namespace %s", statefulSet.Name, statefulSet.Namespace)
}
return nil
}
func (c *Controller) onAdd(obj interface{}) {
nfsObj := obj.(*nfsv1alpha1.NFSServer).DeepCopy()
nfsServer := newNfsServer(nfsObj, c.context)
logger.Infof("new NFS server %s added to namespace %s", nfsObj.Name, nfsServer.namespace)
logger.Infof("validating nfs server spec in namespace %s", nfsServer.namespace)
if err := validateNFSServerSpec(nfsServer.spec); err != nil {
logger.Errorf("Invalid NFS Server spec: %+v", err)
return
}
logger.Infof("creating nfs server service in namespace %s", nfsServer.namespace)
if err := c.createNFSService(nfsServer); err != nil {
logger.Errorf("Unable to create NFS service %+v", err)
}
logger.Infof("creating nfs server configuration in namespace %s", nfsServer.namespace)
if err := c.createNFSConfigMap(nfsServer); err != nil {
logger.Errorf("Unable to create NFS ConfigMap %+v", err)
}
logger.Infof("creating nfs server stateful set in namespace %s", nfsServer.namespace)
if err := c.createNfsStatefulSet(nfsServer, int32(nfsServer.spec.Replicas)); err != nil {
logger.Errorf("Unable to create NFS stateful set %+v", err)
}
}
func (c *Controller) onUpdate(oldObj, newObj interface{}) {
oldNfsServ := oldObj.(*nfsv1alpha1.NFSServer).DeepCopy()
logger.Infof("Received update on NFS server %s in namespace %s. This is currently unsupported.", oldNfsServ.Name, oldNfsServ.Namespace)
}
func (c *Controller) onDelete(obj interface{}) {
cluster := obj.(*nfsv1alpha1.NFSServer).DeepCopy()
logger.Infof("cluster %s deleted from namespace %s", cluster.Name, cluster.Namespace)
}
func validateNFSServerSpec(spec nfsv1alpha1.NFSServerSpec) error {
serverConfig := spec.Exports
for _, export := range serverConfig {
if err := validateAccessMode(export.Server.AccessMode); err != nil {
return err
}
if err := validateSquashMode(export.Server.Squash); err != nil {
return err
}
}
return nil
}
func | validateAccessMode | identifier_name | |
controller.go | getServerConfig(spec.Exports)
exportsList := make([]string, 0)
id := 10
for claimName, claimConfig := range serverConfig {
exportsList = append(exportsList, createGaneshaExport(id, claimName, claimConfig["accessMode"], claimConfig["squash"]))
id++
}
// fsid_device parameter is important as in case of an overlayfs there is a chance that the fsid of the mounted share is same as that of the fsid of "/"
// so setting this to true uses device number as fsid
// related issue https://github.com/nfs-ganesha/nfs-ganesha/issues/140
exportsList = append(exportsList, `NFS_Core_Param
{
fsid_device = true;
}`)
nfsGaneshaConfig := s.Join(exportsList, "\n")
return nfsGaneshaConfig
}
func (c *Controller) createNFSConfigMap(nfsServer *nfsServer) error {
nfsGaneshaConfig := createGaneshaConfig(&nfsServer.spec)
configMap := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: nfsConfigMapName,
Namespace: nfsServer.namespace,
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
Labels: createAppLabels(),
},
Data: map[string]string{
nfsConfigMapName: nfsGaneshaConfig,
},
}
_, err := c.context.Clientset.CoreV1().ConfigMaps(nfsServer.namespace).Create(configMap)
if err != nil {
return err
}
return nil
}
func getPVCNameList(spec *nfsv1alpha1.NFSServerSpec) []string {
exports := spec.Exports
pvcNameList := make([]string, 0)
for _, export := range exports {
claimName := export.PersistentVolumeClaim.ClaimName
if claimName != "" {
pvcNameList = append(pvcNameList, claimName)
}
}
return pvcNameList
}
func createPVCSpecList(spec *nfsv1alpha1.NFSServerSpec) []v1.Volume {
pvcSpecList := make([]v1.Volume, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
pvcSpecList = append(pvcSpecList, v1.Volume{
Name: claimName,
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: claimName,
},
},
})
}
configMapSrc := &v1.ConfigMapVolumeSource{
Items: []v1.KeyToPath{
{
Key: nfsConfigMapName,
Path: nfsConfigMapName,
},
},
}
configMapSrc.Name = nfsConfigMapName
configMapVol := v1.Volume{
Name: nfsConfigMapName,
VolumeSource: v1.VolumeSource{
ConfigMap: configMapSrc,
},
}
pvcSpecList = append(pvcSpecList, configMapVol)
return pvcSpecList
}
func createVolumeMountList(spec *nfsv1alpha1.NFSServerSpec) []v1.VolumeMount {
volumeMountList := make([]v1.VolumeMount, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
volumeMountList = append(volumeMountList, v1.VolumeMount{
Name: claimName,
MountPath: "/" + claimName,
})
}
configMapVolMount := v1.VolumeMount{
Name: nfsConfigMapName,
MountPath: nfsConfigMapPath,
}
volumeMountList = append(volumeMountList, configMapVolMount)
return volumeMountList
}
func (c *Controller) createNfsPodSpec(nfsServer *nfsServer) v1.PodTemplateSpec {
nfsPodSpec := v1.PodTemplateSpec{
ObjectMeta: metav1.ObjectMeta{
Name: nfsServer.name,
Namespace: nfsServer.namespace,
Labels: createAppLabels(),
},
Spec: v1.PodSpec{
Containers: []v1.Container{
{
Name: nfsServer.name,
Image: c.containerImage,
Command: []string{"/start.sh"},
Ports: []v1.ContainerPort{
{
Name: "nfs-port",
ContainerPort: int32(nfsPort),
},
{
Name: "rpc-port",
ContainerPort: int32(rpcPort),
},
},
VolumeMounts: createVolumeMountList(&nfsServer.spec),
SecurityContext: &v1.SecurityContext{
Capabilities: &v1.Capabilities{
Add: []v1.Capability{
"SYS_ADMIN",
"DAC_READ_SEARCH",
},
},
},
},
},
Volumes: createPVCSpecList(&nfsServer.spec),
},
}
return nfsPodSpec
}
func (c *Controller) createNfsStatefulSet(nfsServer *nfsServer, replicas int32) error {
appsClient := c.context.Clientset.AppsV1beta1()
nfsPodSpec := c.createNfsPodSpec(nfsServer)
statefulSet := v1beta1.StatefulSet{
ObjectMeta: metav1.ObjectMeta{
Name: nfsServer.name,
Namespace: nfsServer.namespace,
Labels: createAppLabels(),
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
},
Spec: v1beta1.StatefulSetSpec{
Replicas: &replicas,
Selector: &metav1.LabelSelector{
MatchLabels: createAppLabels(),
},
Template: nfsPodSpec,
ServiceName: nfsServer.name,
},
}
if _, err := appsClient.StatefulSets(nfsServer.namespace).Create(&statefulSet); err != nil {
if !errors.IsAlreadyExists(err) {
return err
}
logger.Infof("stateful set %s already exists in namespace %s", statefulSet.Name, statefulSet.Namespace)
} else {
logger.Infof("stateful set %s created in namespace %s", statefulSet.Name, statefulSet.Namespace)
}
return nil
}
func (c *Controller) onAdd(obj interface{}) {
nfsObj := obj.(*nfsv1alpha1.NFSServer).DeepCopy()
nfsServer := newNfsServer(nfsObj, c.context)
logger.Infof("new NFS server %s added to namespace %s", nfsObj.Name, nfsServer.namespace)
logger.Infof("validating nfs server spec in namespace %s", nfsServer.namespace)
if err := validateNFSServerSpec(nfsServer.spec); err != nil {
logger.Errorf("Invalid NFS Server spec: %+v", err)
return
}
logger.Infof("creating nfs server service in namespace %s", nfsServer.namespace)
if err := c.createNFSService(nfsServer); err != nil {
logger.Errorf("Unable to create NFS service %+v", err)
}
logger.Infof("creating nfs server configuration in namespace %s", nfsServer.namespace)
if err := c.createNFSConfigMap(nfsServer); err != nil {
logger.Errorf("Unable to create NFS ConfigMap %+v", err)
}
logger.Infof("creating nfs server stateful set in namespace %s", nfsServer.namespace)
if err := c.createNfsStatefulSet(nfsServer, int32(nfsServer.spec.Replicas)); err != nil {
logger.Errorf("Unable to create NFS stateful set %+v", err)
}
}
func (c *Controller) onUpdate(oldObj, newObj interface{}) {
oldNfsServ := oldObj.(*nfsv1alpha1.NFSServer).DeepCopy()
logger.Infof("Received update on NFS server %s in namespace %s. This is currently unsupported.", oldNfsServ.Name, oldNfsServ.Namespace)
}
func (c *Controller) onDelete(obj interface{}) {
cluster := obj.(*nfsv1alpha1.NFSServer).DeepCopy()
logger.Infof("cluster %s deleted from namespace %s", cluster.Name, cluster.Namespace)
}
func validateNFSServerSpec(spec nfsv1alpha1.NFSServerSpec) error {
serverConfig := spec.Exports
for _, export := range serverConfig {
if err := validateAccessMode(export.Server.AccessMode); err != nil {
return err
}
if err := validateSquashMode(export.Server.Squash); err != nil {
return err
}
}
return nil
}
func validateAccessMode(mode string) error {
switch s.ToLower(mode) {
case "readonly":
case "readwrite":
case "none":
default:
return fmt.Errorf("Invalid value (%s) for accessMode, valid values are (ReadOnly, ReadWrite, none)", mode)
}
return nil
}
func validateSquashMode(mode string) error | {
switch s.ToLower(mode) {
case "none":
case "rootid":
case "root":
case "all":
default:
return fmt.Errorf("Invalid value (%s) for squash, valid values are (none, rootId, root, all)", mode)
}
return nil
} | identifier_body | |
controller.go | }
// Controller represents a controller object for nfs server custom resources
type Controller struct {
context *clusterd.Context
containerImage string
}
// NewController create controller for watching nfsserver custom resources created
func NewController(context *clusterd.Context, containerImage string) *Controller {
return &Controller{
context: context,
containerImage: containerImage,
}
}
// StartWatch watches for instances of nfsserver custom resources and acts on them
func (c *Controller) StartWatch(namespace string, stopCh chan struct{}) error {
resourceHandlerFuncs := cache.ResourceEventHandlerFuncs{
AddFunc: c.onAdd,
UpdateFunc: c.onUpdate,
DeleteFunc: c.onDelete,
}
logger.Infof("start watching nfs server resources in namespace %s", namespace)
watcher := opkit.NewWatcher(NFSResource, namespace, resourceHandlerFuncs, c.context.RookClientset.NfsV1alpha1().RESTClient())
go watcher.Watch(&nfsv1alpha1.NFSServer{}, stopCh)
return nil
}
type nfsServer struct {
name string
context *clusterd.Context
namespace string
spec nfsv1alpha1.NFSServerSpec
ownerRef metav1.OwnerReference
}
func newNfsServer(c *nfsv1alpha1.NFSServer, context *clusterd.Context) *nfsServer {
return &nfsServer{
name: appName,
context: context,
namespace: c.Namespace,
spec: c.Spec,
ownerRef: nfsOwnerRef(c.Namespace, string(c.UID)),
}
}
func nfsOwnerRef(namespace, nfsServerID string) metav1.OwnerReference {
blockOwner := true
return metav1.OwnerReference{
APIVersion: NFSResource.Version,
Kind: NFSResource.Kind,
Name: namespace,
UID: types.UID(nfsServerID),
BlockOwnerDeletion: &blockOwner,
}
}
func getServerConfig(exports []nfsv1alpha1.ExportsSpec) map[string]map[string]string {
claimConfigOpt := make(map[string]map[string]string)
configOpt := make(map[string]string)
for _, export := range exports {
claimName := export.PersistentVolumeClaim.ClaimName
if claimName != "" {
configOpt["accessMode"] = export.Server.AccessMode
configOpt["squash"] = export.Server.Squash
claimConfigOpt[claimName] = configOpt
}
}
return claimConfigOpt
}
func createAppLabels() map[string]string {
return map[string]string{
k8sutil.AppAttr: appName,
}
}
func createServicePorts() []v1.ServicePort {
return []v1.ServicePort{
{
Name: "nfs",
Port: int32(nfsPort),
TargetPort: intstr.FromInt(int(nfsPort)),
},
{
Name: "rpc",
Port: int32(rpcPort),
TargetPort: intstr.FromInt(int(rpcPort)),
},
}
}
func (c *Controller) createNFSService(nfsServer *nfsServer) error {
// This service is meant to be used by clients to access NFS.
nfsService := &v1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: nfsServer.name,
Namespace: nfsServer.namespace,
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
Labels: createAppLabels(),
},
Spec: v1.ServiceSpec{
Selector: createAppLabels(),
Type: v1.ServiceTypeClusterIP,
Ports: createServicePorts(),
},
}
if _, err := c.context.Clientset.CoreV1().Services(nfsServer.namespace).Create(nfsService); err != nil {
if !errors.IsAlreadyExists(err) {
return err
}
logger.Infof("nfs service %s already exists in namespace %s", nfsService.Name, nfsService.Namespace)
} else {
logger.Infof("nfs service %s started in namespace %s", nfsService.Name, nfsService.Namespace)
}
return nil
}
func createGaneshaExport(id int, path string, access string, squash string) string {
var accessType string
// validateNFSServerSpec guarantees `access` will be one of these values at this point
switch s.ToLower(access) {
case "readwrite":
accessType = "RW"
case "readonly":
accessType = "RO"
case "none":
accessType = "None"
}
idStr := fmt.Sprintf("%v", id)
nfsGaneshaConfig := `
EXPORT {
Export_Id = ` + idStr + `;
Path = /` + path + `;
Pseudo = /` + path + `;
Protocols = 4;
Transports = TCP;
Sectype = sys;
Access_Type = ` + accessType + `;
Squash = ` + s.ToLower(squash) + `;
FSAL {
Name = VFS;
}
}`
return nfsGaneshaConfig
}
func createGaneshaConfig(spec *nfsv1alpha1.NFSServerSpec) string {
serverConfig := getServerConfig(spec.Exports)
exportsList := make([]string, 0)
id := 10
for claimName, claimConfig := range serverConfig {
exportsList = append(exportsList, createGaneshaExport(id, claimName, claimConfig["accessMode"], claimConfig["squash"]))
id++
}
// fsid_device parameter is important as in case of an overlayfs there is a chance that the fsid of the mounted share is same as that of the fsid of "/"
// so setting this to true uses device number as fsid
// related issue https://github.com/nfs-ganesha/nfs-ganesha/issues/140
exportsList = append(exportsList, `NFS_Core_Param
{
fsid_device = true;
}`)
nfsGaneshaConfig := s.Join(exportsList, "\n")
return nfsGaneshaConfig
}
func (c *Controller) createNFSConfigMap(nfsServer *nfsServer) error {
nfsGaneshaConfig := createGaneshaConfig(&nfsServer.spec)
configMap := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: nfsConfigMapName,
Namespace: nfsServer.namespace,
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
Labels: createAppLabels(),
},
Data: map[string]string{
nfsConfigMapName: nfsGaneshaConfig,
},
}
_, err := c.context.Clientset.CoreV1().ConfigMaps(nfsServer.namespace).Create(configMap)
if err != nil {
return err
}
return nil
}
func getPVCNameList(spec *nfsv1alpha1.NFSServerSpec) []string {
exports := spec.Exports
pvcNameList := make([]string, 0)
for _, export := range exports {
claimName := export.PersistentVolumeClaim.ClaimName
if claimName != "" {
pvcNameList = append(pvcNameList, claimName)
}
}
return pvcNameList
}
func createPVCSpecList(spec *nfsv1alpha1.NFSServerSpec) []v1.Volume {
pvcSpecList := make([]v1.Volume, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
pvcSpecList = append(pvcSpecList, v1.Volume{
Name: claimName,
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: claimName,
},
},
})
}
configMapSrc := &v1.ConfigMapVolumeSource{
Items: []v1.KeyToPath{
{
Key: nfsConfigMapName,
Path: nfsConfigMapName,
},
},
}
configMapSrc.Name = nfsConfigMapName
configMapVol := v1.Volume{
Name: nfsConfigMapName,
VolumeSource: v1.VolumeSource{
ConfigMap: configMapSrc,
},
}
pvcSpecList = append(pvcSpecList, configMapVol)
return pvcSpecList
}
func createVolumeMountList(spec *nfsv1alpha1.NFSServerSpec) []v1.VolumeMount {
volumeMountList := make([]v1.VolumeMount, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
volumeMountList = append(volumeMountList, v1.VolumeMount{
Name: claimName,
MountPath: "/" + claimName,
})
}
configMapVolMount := v1.VolumeMount{
Name: nfsConfigMapName,
MountPath: nfsConfigMapPath,
}
volumeMountList = append(volumeMountList, configMapVolMount)
return volumeMountList
}
func (c *Controller) createNfsPodSpec(nfs | Group: nfsv1alpha1.CustomResourceGroup,
Version: nfsv1alpha1.Version,
Scope: apiextensionsv1beta1.NamespaceScoped,
Kind: reflect.TypeOf(nfsv1alpha1.NFSServer{}).Name(), | random_line_split | |
controller.go | ,
Scope: apiextensionsv1beta1.NamespaceScoped,
Kind: reflect.TypeOf(nfsv1alpha1.NFSServer{}).Name(),
}
// Controller represents a controller object for nfs server custom resources
type Controller struct {
context *clusterd.Context
containerImage string
}
// NewController create controller for watching nfsserver custom resources created
func NewController(context *clusterd.Context, containerImage string) *Controller {
return &Controller{
context: context,
containerImage: containerImage,
}
}
// StartWatch watches for instances of nfsserver custom resources and acts on them
func (c *Controller) StartWatch(namespace string, stopCh chan struct{}) error {
resourceHandlerFuncs := cache.ResourceEventHandlerFuncs{
AddFunc: c.onAdd,
UpdateFunc: c.onUpdate,
DeleteFunc: c.onDelete,
}
logger.Infof("start watching nfs server resources in namespace %s", namespace)
watcher := opkit.NewWatcher(NFSResource, namespace, resourceHandlerFuncs, c.context.RookClientset.NfsV1alpha1().RESTClient())
go watcher.Watch(&nfsv1alpha1.NFSServer{}, stopCh)
return nil
}
type nfsServer struct {
name string
context *clusterd.Context
namespace string
spec nfsv1alpha1.NFSServerSpec
ownerRef metav1.OwnerReference
}
func newNfsServer(c *nfsv1alpha1.NFSServer, context *clusterd.Context) *nfsServer {
return &nfsServer{
name: appName,
context: context,
namespace: c.Namespace,
spec: c.Spec,
ownerRef: nfsOwnerRef(c.Namespace, string(c.UID)),
}
}
func nfsOwnerRef(namespace, nfsServerID string) metav1.OwnerReference {
blockOwner := true
return metav1.OwnerReference{
APIVersion: NFSResource.Version,
Kind: NFSResource.Kind,
Name: namespace,
UID: types.UID(nfsServerID),
BlockOwnerDeletion: &blockOwner,
}
}
func getServerConfig(exports []nfsv1alpha1.ExportsSpec) map[string]map[string]string {
claimConfigOpt := make(map[string]map[string]string)
configOpt := make(map[string]string)
for _, export := range exports {
claimName := export.PersistentVolumeClaim.ClaimName
if claimName != "" {
configOpt["accessMode"] = export.Server.AccessMode
configOpt["squash"] = export.Server.Squash
claimConfigOpt[claimName] = configOpt
}
}
return claimConfigOpt
}
func createAppLabels() map[string]string {
return map[string]string{
k8sutil.AppAttr: appName,
}
}
func createServicePorts() []v1.ServicePort {
return []v1.ServicePort{
{
Name: "nfs",
Port: int32(nfsPort),
TargetPort: intstr.FromInt(int(nfsPort)),
},
{
Name: "rpc",
Port: int32(rpcPort),
TargetPort: intstr.FromInt(int(rpcPort)),
},
}
}
func (c *Controller) createNFSService(nfsServer *nfsServer) error {
// This service is meant to be used by clients to access NFS.
nfsService := &v1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: nfsServer.name,
Namespace: nfsServer.namespace,
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
Labels: createAppLabels(),
},
Spec: v1.ServiceSpec{
Selector: createAppLabels(),
Type: v1.ServiceTypeClusterIP,
Ports: createServicePorts(),
},
}
if _, err := c.context.Clientset.CoreV1().Services(nfsServer.namespace).Create(nfsService); err != nil {
if !errors.IsAlreadyExists(err) {
return err
}
logger.Infof("nfs service %s already exists in namespace %s", nfsService.Name, nfsService.Namespace)
} else {
logger.Infof("nfs service %s started in namespace %s", nfsService.Name, nfsService.Namespace)
}
return nil
}
func createGaneshaExport(id int, path string, access string, squash string) string {
var accessType string
// validateNFSServerSpec guarantees `access` will be one of these values at this point
switch s.ToLower(access) {
case "readwrite":
accessType = "RW"
case "readonly":
accessType = "RO"
case "none":
accessType = "None"
}
idStr := fmt.Sprintf("%v", id)
nfsGaneshaConfig := `
EXPORT {
Export_Id = ` + idStr + `;
Path = /` + path + `;
Pseudo = /` + path + `;
Protocols = 4;
Transports = TCP;
Sectype = sys;
Access_Type = ` + accessType + `;
Squash = ` + s.ToLower(squash) + `;
FSAL {
Name = VFS;
}
}`
return nfsGaneshaConfig
}
func createGaneshaConfig(spec *nfsv1alpha1.NFSServerSpec) string {
serverConfig := getServerConfig(spec.Exports)
exportsList := make([]string, 0)
id := 10
for claimName, claimConfig := range serverConfig {
exportsList = append(exportsList, createGaneshaExport(id, claimName, claimConfig["accessMode"], claimConfig["squash"]))
id++
}
// fsid_device parameter is important as in case of an overlayfs there is a chance that the fsid of the mounted share is same as that of the fsid of "/"
// so setting this to true uses device number as fsid
// related issue https://github.com/nfs-ganesha/nfs-ganesha/issues/140
exportsList = append(exportsList, `NFS_Core_Param
{
fsid_device = true;
}`)
nfsGaneshaConfig := s.Join(exportsList, "\n")
return nfsGaneshaConfig
}
func (c *Controller) createNFSConfigMap(nfsServer *nfsServer) error {
nfsGaneshaConfig := createGaneshaConfig(&nfsServer.spec)
configMap := &v1.ConfigMap{
ObjectMeta: metav1.ObjectMeta{
Name: nfsConfigMapName,
Namespace: nfsServer.namespace,
OwnerReferences: []metav1.OwnerReference{nfsServer.ownerRef},
Labels: createAppLabels(),
},
Data: map[string]string{
nfsConfigMapName: nfsGaneshaConfig,
},
}
_, err := c.context.Clientset.CoreV1().ConfigMaps(nfsServer.namespace).Create(configMap)
if err != nil {
return err
}
return nil
}
func getPVCNameList(spec *nfsv1alpha1.NFSServerSpec) []string {
exports := spec.Exports
pvcNameList := make([]string, 0)
for _, export := range exports |
return pvcNameList
}
func createPVCSpecList(spec *nfsv1alpha1.NFSServerSpec) []v1.Volume {
pvcSpecList := make([]v1.Volume, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
pvcSpecList = append(pvcSpecList, v1.Volume{
Name: claimName,
VolumeSource: v1.VolumeSource{
PersistentVolumeClaim: &v1.PersistentVolumeClaimVolumeSource{
ClaimName: claimName,
},
},
})
}
configMapSrc := &v1.ConfigMapVolumeSource{
Items: []v1.KeyToPath{
{
Key: nfsConfigMapName,
Path: nfsConfigMapName,
},
},
}
configMapSrc.Name = nfsConfigMapName
configMapVol := v1.Volume{
Name: nfsConfigMapName,
VolumeSource: v1.VolumeSource{
ConfigMap: configMapSrc,
},
}
pvcSpecList = append(pvcSpecList, configMapVol)
return pvcSpecList
}
func createVolumeMountList(spec *nfsv1alpha1.NFSServerSpec) []v1.VolumeMount {
volumeMountList := make([]v1.VolumeMount, 0)
pvcNameList := getPVCNameList(spec)
for _, claimName := range pvcNameList {
volumeMountList = append(volumeMountList, v1.VolumeMount{
Name: claimName,
MountPath: "/" + claimName,
})
}
configMapVolMount := v1.VolumeMount{
Name: nfsConfigMapName,
MountPath: nfsConfigMapPath,
}
volumeMountList = append(volumeMountList, configMapVolMount)
return volumeMountList
}
func (c *Controller) createNfsPodSpec(nfsServer *nfsServer) v1.PodTemplateSpec {
nfsPodSpec := v1 | {
claimName := export.PersistentVolumeClaim.ClaimName
if claimName != "" {
pvcNameList = append(pvcNameList, claimName)
}
} | conditional_block |
role_conversion.py | $',
'soc.tasks.updates.role_conversion.updateHosts'),
]
return patterns
class HostUpdater(object):
"""Class which is responsible for updating Host entities.
"""
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key, batch_size):
"""Retrieves Host entities and updates them.
"""
query = Host.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
sponsor = entity.scope
host_for = entity.user.host_for
if not host_for:
host_for = []
user = entity.user
if sponsor.key() not in host_for:
host_for.append(sponsor.key())
user.host_for = host_for
db.put(user)
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
class RoleUpdater(object):
"""Class which is responsible for updating the entities.
"""
def __init__(self, model, profile_model, program_field, role_field=None):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.PROGRAM_FIELD = program_field
self.ROLE_FIELD = role_field
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _processEntity(self, entity):
program = getattr(entity, self.PROGRAM_FIELD)
user = entity.user
# try to find an existing Profile entity or create a new one
key_name = program.key().name() + '/' + user.link_id
properties = {
'link_id': entity.link_id,
'scope_path': program.key().name(),
'scope': program,
'parent': user,
}
for prop in POPULATED_PROFILE_PROPS:
properties[prop] = getattr(entity, prop)
profile = self.PROFILE_MODEL.get_or_insert(
key_name=key_name, **properties)
# do not update anything if the role is already in the profile
if profile.student_info and self.MODEL == GSoCStudent:
return
elif self.ROLE_FIELD:
if entity.scope.key() in getattr(profile, self.ROLE_FIELD):
return
to_put = [profile]
# a non-invalid role is found, we should re-populate the profile
if profile.status == 'invalid' and entity.status != 'invalid':
for prop_name in entity.properties():
value = getattr(entity, prop_name)
setattr(profile, prop_name, value)
if profile.student_info:
profile.student_info = None
if self.ROLE_FIELD:
# the role is either Mentor or OrgAdmin
getattr(profile, self.ROLE_FIELD).append(entity.scope.key())
else:
# the role is certainly Student; we have to create a new StudentInfo
properties = {}
for prop in POPULATED_STUDENT_PROPS:
properties[prop] = getattr(entity, prop)
key_name = profile.key().name()
student_info = StudentInfo(key_name=key_name,
parent=profile, **properties)
profile.student_info = student_info
to_put.append(student_info)
db.run_in_transaction(db.put, to_put)
def _process(self, start_key, batch_size):
"""Retrieves entities and creates or updates a corresponding
Profile entity.
"""
query = self.MODEL.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
try:
self._processEntity(entity)
except db.Error, e:
import logging
logging.exception(e)
logging.error("Broke on %s: %s" % (entity.key().name(), self.MODEL))
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
def updateHosts(request):
"""Starts a task which updates Host entities.
"""
updater = HostUpdater()
updater.run()
return http.HttpResponse("Ok")
def updateRole(role_name):
"""Starts a task which updates a particular role.
"""
if role_name == 'gsoc_mentor':
updater = RoleUpdater(GSoCMentor, GSoCProfile, 'program', 'mentor_for')
elif role_name == 'gsoc_org_admin':
updater = RoleUpdater(
GSoCOrgAdmin, GSoCProfile, 'program', 'org_admin_for')
elif role_name == 'gsoc_student':
updater = RoleUpdater(GSoCStudent, GSoCProfile, 'scope')
updater.run()
return http.HttpResponse("Ok")
def updateRoles(request):
"""Starts a bunch of iterative tasks which update particular roles.
In order to prevent issues with concurrent access to entities, we set
ETA so that each role is processed in separation.
"""
# update org admins
#updateRole('gsoc_org_admin')
# update mentors
#updateRole('gsoc_mentor')
# update students
# we can assume that students cannot have any other roles, so we do not
# need to set ETA
updateRole('gsoc_student')
def updateMentors(request):
"""Starts an iterative task which update mentors.
"""
return updateRole('gsoc_mentor')
def updateOrgAdmins(request):
"""Starts an iterative task which update org admins.
"""
return updateRole('gsoc_org_admin')
def updateStudents(request):
"""Starts an iterative task which update students.
"""
return updateRole('gsoc_student')
def _getProfileForRole(entity, profile_model):
"""Returns GSoCProfile or GCIProfile which corresponds to the specified
entity.
"""
if isinstance(entity, profile_model):
return entity
if isinstance(entity, OrgAdmin) or isinstance(entity, Mentor):
key_name = entity.program.key().name() + '/' + entity.user.key().name()
else:
key_name = entity.key().name()
parent = entity.user
return profile_model.get_by_key_name(key_name, parent=parent)
def _getProfileKeyForRoleKey(key, profile_model):
"""Returns Key instance of the Profile which corresponds to the Role which
is represented by the specified Key.
"""
entity = db.get(key)
profile = _getProfileForRole(entity, profile_model)
return profile.key()
class ReferenceUpdater(object):
"""Class which is responsible for updating references to Profile in
the specified model.
"""
def __init__(self, model, profile_model, fields_to_update,
lists_to_update=[]):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.FIELDS_TO_UPDATE = fields_to_update
self.LISTS_TO_UPDATE = lists_to_update
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key, batch_size):
"""Iterates through the entities and updates the references.
"""
query = self.MODEL.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
for field in self.FIELDS_TO_UPDATE:
old_reference = getattr(entity, field)
if not old_reference:
continue
# check if the field has not been updated
if isinstance(old_reference, self.PROFILE_MODEL):
continue
profile = _getProfileForRole(old_reference, self.PROFILE_MODEL)
setattr(entity, field, profile)
for list_property in self.LISTS_TO_UPDATE:
l = getattr(entity, list_property)
new_l = []
for key in l:
new_l.append(_getProfileKeyForRoleKey(key, self.PROFILE_MODEL))
setattr(entity, list_property, new_l)
db.put(entities)
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
def updateReferencesForModel(model):
"""Starts a task which updates references for a particular model.
"""
if model == 'student_proposal':
updater = ReferenceUpdater(StudentProposal, GSoCProfile,
['scope', 'mentor'], ['possible_mentors'])
elif model == 'student_project':
updater = ReferenceUpdater(StudentProject, GSoCProfile,
['mentor', 'student'], ['additional_mentors'])
updater.run()
return http.HttpResponse("Ok")
def updateStudentProjectReferences(request):
| """Starts a bunch of iterative tasks which update references in
StudentProjects.
"""
return updateReferencesForModel('student_project') | identifier_body | |
role_conversion.py | Host
from soc.models.linkable import Linkable
from soc.models.mentor import Mentor
from soc.models.org_admin import OrgAdmin
from soc.models.role import StudentInfo
from soc.modules.gsoc.models.mentor import GSoCMentor
from soc.modules.gsoc.models.organization import GSoCOrganization
from soc.modules.gsoc.models.org_admin import GSoCOrgAdmin
from soc.modules.gsoc.models.profile import GSoCProfile
from soc.modules.gsoc.models.program import GSoCProgram
from soc.modules.gsoc.models.student import GSoCStudent
from soc.modules.gsoc.models.student_project import StudentProject
from soc.modules.gsoc.models.student_proposal import StudentProposal
ROLE_MODELS = [GSoCMentor, GSoCOrgAdmin, GSoCStudent]
POPULATED_PROFILE_PROPS = set(
GSoCProfile.properties()) - set(Linkable.properties())
POPULATED_STUDENT_PROPS = StudentInfo.properties()
def getDjangoURLPatterns():
"""Returns the URL patterns for the tasks in this module.
"""
patterns = [
(r'^tasks/role_conversion/update_references',
'soc.tasks.updates.role_conversion.updateReferences'),
(r'^tasks/role_conversion/update_project_references',
'soc.tasks.updates.role_conversion.updateStudentProjectReferences'),
(r'^tasks/role_conversion/update_proposal_references',
'soc.tasks.updates.role_conversion.updateStudentProposalReferences'),
(r'^tasks/role_conversion/update_roles$',
'soc.tasks.updates.role_conversion.updateRoles'),
(r'^tasks/role_conversion/update_mentors$',
'soc.tasks.updates.role_conversion.updateMentors'),
(r'^tasks/role_conversion/update_org_admins$',
'soc.tasks.updates.role_conversion.updateOrgAdmins'),
(r'^tasks/role_conversion/update_students$',
'soc.tasks.updates.role_conversion.updateStudents'),
(r'^tasks/role_conversion/update_hosts$',
'soc.tasks.updates.role_conversion.updateHosts'),
]
return patterns
class HostUpdater(object):
"""Class which is responsible for updating Host entities.
"""
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key, batch_size):
"""Retrieves Host entities and updates them.
"""
query = Host.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
sponsor = entity.scope
host_for = entity.user.host_for
if not host_for:
host_for = []
user = entity.user
if sponsor.key() not in host_for:
host_for.append(sponsor.key())
user.host_for = host_for
db.put(user)
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
class RoleUpdater(object):
"""Class which is responsible for updating the entities.
"""
def __init__(self, model, profile_model, program_field, role_field=None):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.PROGRAM_FIELD = program_field
self.ROLE_FIELD = role_field
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _processEntity(self, entity):
program = getattr(entity, self.PROGRAM_FIELD)
user = entity.user
# try to find an existing Profile entity or create a new one
key_name = program.key().name() + '/' + user.link_id
properties = {
'link_id': entity.link_id,
'scope_path': program.key().name(),
'scope': program,
'parent': user,
}
for prop in POPULATED_PROFILE_PROPS:
properties[prop] = getattr(entity, prop)
profile = self.PROFILE_MODEL.get_or_insert(
key_name=key_name, **properties)
# do not update anything if the role is already in the profile
if profile.student_info and self.MODEL == GSoCStudent:
return
elif self.ROLE_FIELD:
if entity.scope.key() in getattr(profile, self.ROLE_FIELD):
return
to_put = [profile]
# a non-invalid role is found, we should re-populate the profile
if profile.status == 'invalid' and entity.status != 'invalid':
for prop_name in entity.properties():
value = getattr(entity, prop_name)
setattr(profile, prop_name, value)
if profile.student_info:
profile.student_info = None
if self.ROLE_FIELD:
# the role is either Mentor or OrgAdmin
getattr(profile, self.ROLE_FIELD).append(entity.scope.key())
else:
# the role is certainly Student; we have to create a new StudentInfo
properties = {}
for prop in POPULATED_STUDENT_PROPS:
properties[prop] = getattr(entity, prop)
key_name = profile.key().name()
student_info = StudentInfo(key_name=key_name,
parent=profile, **properties)
profile.student_info = student_info
to_put.append(student_info)
db.run_in_transaction(db.put, to_put)
def _process(self, start_key, batch_size):
"""Retrieves entities and creates or updates a corresponding
Profile entity.
"""
query = self.MODEL.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
try:
self._processEntity(entity)
except db.Error, e:
import logging
logging.exception(e)
logging.error("Broke on %s: %s" % (entity.key().name(), self.MODEL))
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
def | (request):
"""Starts a task which updates Host entities.
"""
updater = HostUpdater()
updater.run()
return http.HttpResponse("Ok")
def updateRole(role_name):
"""Starts a task which updates a particular role.
"""
if role_name == 'gsoc_mentor':
updater = RoleUpdater(GSoCMentor, GSoCProfile, 'program', 'mentor_for')
elif role_name == 'gsoc_org_admin':
updater = RoleUpdater(
GSoCOrgAdmin, GSoCProfile, 'program', 'org_admin_for')
elif role_name == 'gsoc_student':
updater = RoleUpdater(GSoCStudent, GSoCProfile, 'scope')
updater.run()
return http.HttpResponse("Ok")
def updateRoles(request):
"""Starts a bunch of iterative tasks which update particular roles.
In order to prevent issues with concurrent access to entities, we set
ETA so that each role is processed in separation.
"""
# update org admins
#updateRole('gsoc_org_admin')
# update mentors
#updateRole('gsoc_mentor')
# update students
# we can assume that students cannot have any other roles, so we do not
# need to set ETA
updateRole('gsoc_student')
def updateMentors(request):
"""Starts an iterative task which update mentors.
"""
return updateRole('gsoc_mentor')
def updateOrgAdmins(request):
"""Starts an iterative task which update org admins.
"""
return updateRole('gsoc_org_admin')
def updateStudents(request):
"""Starts an iterative task which update students.
"""
return updateRole('gsoc_student')
def _getProfileForRole(entity, profile_model):
"""Returns GSoCProfile or GCIProfile which corresponds to the specified
entity.
"""
if isinstance(entity, profile_model):
return entity
if isinstance(entity, OrgAdmin) or isinstance(entity, Mentor):
key_name = entity.program.key().name() + '/' + entity.user.key().name()
else:
key_name = entity.key().name()
parent = entity.user
return profile_model.get_by_key_name(key_name, parent=parent)
def _getProfileKeyForRoleKey(key, profile_model):
"""Returns Key instance of the Profile which corresponds to the Role which
is represented by the specified Key.
"""
entity = db.get(key)
profile = _getProfileForRole(entity, profile_model)
return profile.key()
class ReferenceUpdater(object):
"""Class which is responsible for updating references to Profile in
the specified model.
"""
def __init__(self, model, profile_model, fields_to_update,
lists_to_update=[]):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.FIELDS_TO_UPDATE = fields_to_update
self.LISTS_TO_UPDATE = lists_to_update
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key | updateHosts | identifier_name |
role_conversion.py | # 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.
"""The role conversion updates are defined in this module.
"""
__authors__ = [
'"Daniel Hans" <daniel.m.hans@gmail.com>',
]
import gae_django
from google.appengine.ext import db
from google.appengine.ext import deferred
from google.appengine.runtime import DeadlineExceededError
from django import http
from soc.models.host import Host
from soc.models.linkable import Linkable
from soc.models.mentor import Mentor
from soc.models.org_admin import OrgAdmin
from soc.models.role import StudentInfo
from soc.modules.gsoc.models.mentor import GSoCMentor
from soc.modules.gsoc.models.organization import GSoCOrganization
from soc.modules.gsoc.models.org_admin import GSoCOrgAdmin
from soc.modules.gsoc.models.profile import GSoCProfile
from soc.modules.gsoc.models.program import GSoCProgram
from soc.modules.gsoc.models.student import GSoCStudent
from soc.modules.gsoc.models.student_project import StudentProject
from soc.modules.gsoc.models.student_proposal import StudentProposal
ROLE_MODELS = [GSoCMentor, GSoCOrgAdmin, GSoCStudent]
POPULATED_PROFILE_PROPS = set(
GSoCProfile.properties()) - set(Linkable.properties())
POPULATED_STUDENT_PROPS = StudentInfo.properties()
def getDjangoURLPatterns():
"""Returns the URL patterns for the tasks in this module.
"""
patterns = [
(r'^tasks/role_conversion/update_references',
'soc.tasks.updates.role_conversion.updateReferences'),
(r'^tasks/role_conversion/update_project_references',
'soc.tasks.updates.role_conversion.updateStudentProjectReferences'),
(r'^tasks/role_conversion/update_proposal_references',
'soc.tasks.updates.role_conversion.updateStudentProposalReferences'),
(r'^tasks/role_conversion/update_roles$',
'soc.tasks.updates.role_conversion.updateRoles'),
(r'^tasks/role_conversion/update_mentors$',
'soc.tasks.updates.role_conversion.updateMentors'),
(r'^tasks/role_conversion/update_org_admins$',
'soc.tasks.updates.role_conversion.updateOrgAdmins'),
(r'^tasks/role_conversion/update_students$',
'soc.tasks.updates.role_conversion.updateStudents'),
(r'^tasks/role_conversion/update_hosts$',
'soc.tasks.updates.role_conversion.updateHosts'),
]
return patterns
class HostUpdater(object):
"""Class which is responsible for updating Host entities.
"""
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key, batch_size):
"""Retrieves Host entities and updates them.
"""
query = Host.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
sponsor = entity.scope
host_for = entity.user.host_for
if not host_for:
host_for = []
user = entity.user
if sponsor.key() not in host_for:
host_for.append(sponsor.key())
user.host_for = host_for
db.put(user)
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
class RoleUpdater(object):
"""Class which is responsible for updating the entities.
"""
def __init__(self, model, profile_model, program_field, role_field=None):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.PROGRAM_FIELD = program_field
self.ROLE_FIELD = role_field
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _processEntity(self, entity):
program = getattr(entity, self.PROGRAM_FIELD)
user = entity.user
# try to find an existing Profile entity or create a new one
key_name = program.key().name() + '/' + user.link_id
properties = {
'link_id': entity.link_id,
'scope_path': program.key().name(),
'scope': program,
'parent': user,
}
for prop in POPULATED_PROFILE_PROPS:
properties[prop] = getattr(entity, prop)
profile = self.PROFILE_MODEL.get_or_insert(
key_name=key_name, **properties)
# do not update anything if the role is already in the profile
if profile.student_info and self.MODEL == GSoCStudent:
return
elif self.ROLE_FIELD:
if entity.scope.key() in getattr(profile, self.ROLE_FIELD):
return
to_put = [profile]
# a non-invalid role is found, we should re-populate the profile
if profile.status == 'invalid' and entity.status != 'invalid':
for prop_name in entity.properties():
value = getattr(entity, prop_name)
setattr(profile, prop_name, value)
if profile.student_info:
profile.student_info = None
if self.ROLE_FIELD:
# the role is either Mentor or OrgAdmin
getattr(profile, self.ROLE_FIELD).append(entity.scope.key())
else:
# the role is certainly Student; we have to create a new StudentInfo
properties = {}
for prop in POPULATED_STUDENT_PROPS:
properties[prop] = getattr(entity, prop)
key_name = profile.key().name()
student_info = StudentInfo(key_name=key_name,
parent=profile, **properties)
profile.student_info = student_info
to_put.append(student_info)
db.run_in_transaction(db.put, to_put)
def _process(self, start_key, batch_size):
"""Retrieves entities and creates or updates a corresponding
Profile entity.
"""
query = self.MODEL.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
try:
self._processEntity(entity)
except db.Error, e:
import logging
logging.exception(e)
logging.error("Broke on %s: %s" % (entity.key().name(), self.MODEL))
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
def updateHosts(request):
"""Starts a task which updates Host entities.
"""
updater = HostUpdater()
updater.run()
return http.HttpResponse("Ok")
def updateRole(role_name):
"""Starts a task which updates a particular role.
"""
if role_name == 'gsoc_mentor':
updater = RoleUpdater(GSoCMentor, GSoCProfile, 'program', 'mentor_for')
elif role_name == 'gsoc_org_admin':
updater = RoleUpdater(
GSoCOrgAdmin, GSoCProfile, 'program', 'org_admin_for')
elif role_name == 'gsoc_student':
updater = RoleUpdater(GSoCStudent, GSoCProfile, 'scope')
updater.run()
return http.HttpResponse("Ok")
def updateRoles(request):
"""Starts a bunch of iterative tasks which update particular roles.
In order to prevent issues with concurrent access to entities, we set
ETA so that each role is processed in separation.
"""
# update org admins
#updateRole('gsoc_org_admin')
# update mentors
#updateRole('gsoc_mentor')
# update students
# we can assume that students cannot have any other roles, so we do not
# need to set ETA
updateRole('gsoc_student')
def updateMentors(request):
"""Starts an iterative task which update mentors.
"""
return updateRole('gsoc_mentor')
def updateOrgAdmins(request):
"""Starts an iterative task which update org admins.
"""
return updateRole('gsoc_org_admin')
def updateStudents(request):
"""Starts an iterative task which update students.
"""
return updateRole('gsoc_student')
def _getProfileForRole(entity, profile_model):
"""Returns GSoCProfile or GCIProfile which corresponds to the specified
entity.
"""
if isinstance(entity, profile_model):
return entity
if isinstance(entity, OrgAdmin) or isinstance(entity, Mentor):
key_name = entity.program.key().name() + '/' + entity.user.key().name()
else:
key_name = entity.key().name()
parent = entity.user
return profile_model.get_by_key_name(key_name, parent=parent)
def _getProfileKeyForRoleKey(key, profile_model):
"""Returns Key instance of the Profile | # You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
# | random_line_split | |
role_conversion.py | Host
from soc.models.linkable import Linkable
from soc.models.mentor import Mentor
from soc.models.org_admin import OrgAdmin
from soc.models.role import StudentInfo
from soc.modules.gsoc.models.mentor import GSoCMentor
from soc.modules.gsoc.models.organization import GSoCOrganization
from soc.modules.gsoc.models.org_admin import GSoCOrgAdmin
from soc.modules.gsoc.models.profile import GSoCProfile
from soc.modules.gsoc.models.program import GSoCProgram
from soc.modules.gsoc.models.student import GSoCStudent
from soc.modules.gsoc.models.student_project import StudentProject
from soc.modules.gsoc.models.student_proposal import StudentProposal
ROLE_MODELS = [GSoCMentor, GSoCOrgAdmin, GSoCStudent]
POPULATED_PROFILE_PROPS = set(
GSoCProfile.properties()) - set(Linkable.properties())
POPULATED_STUDENT_PROPS = StudentInfo.properties()
def getDjangoURLPatterns():
"""Returns the URL patterns for the tasks in this module.
"""
patterns = [
(r'^tasks/role_conversion/update_references',
'soc.tasks.updates.role_conversion.updateReferences'),
(r'^tasks/role_conversion/update_project_references',
'soc.tasks.updates.role_conversion.updateStudentProjectReferences'),
(r'^tasks/role_conversion/update_proposal_references',
'soc.tasks.updates.role_conversion.updateStudentProposalReferences'),
(r'^tasks/role_conversion/update_roles$',
'soc.tasks.updates.role_conversion.updateRoles'),
(r'^tasks/role_conversion/update_mentors$',
'soc.tasks.updates.role_conversion.updateMentors'),
(r'^tasks/role_conversion/update_org_admins$',
'soc.tasks.updates.role_conversion.updateOrgAdmins'),
(r'^tasks/role_conversion/update_students$',
'soc.tasks.updates.role_conversion.updateStudents'),
(r'^tasks/role_conversion/update_hosts$',
'soc.tasks.updates.role_conversion.updateHosts'),
]
return patterns
class HostUpdater(object):
"""Class which is responsible for updating Host entities.
"""
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key, batch_size):
"""Retrieves Host entities and updates them.
"""
query = Host.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
|
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
class RoleUpdater(object):
"""Class which is responsible for updating the entities.
"""
def __init__(self, model, profile_model, program_field, role_field=None):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.PROGRAM_FIELD = program_field
self.ROLE_FIELD = role_field
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _processEntity(self, entity):
program = getattr(entity, self.PROGRAM_FIELD)
user = entity.user
# try to find an existing Profile entity or create a new one
key_name = program.key().name() + '/' + user.link_id
properties = {
'link_id': entity.link_id,
'scope_path': program.key().name(),
'scope': program,
'parent': user,
}
for prop in POPULATED_PROFILE_PROPS:
properties[prop] = getattr(entity, prop)
profile = self.PROFILE_MODEL.get_or_insert(
key_name=key_name, **properties)
# do not update anything if the role is already in the profile
if profile.student_info and self.MODEL == GSoCStudent:
return
elif self.ROLE_FIELD:
if entity.scope.key() in getattr(profile, self.ROLE_FIELD):
return
to_put = [profile]
# a non-invalid role is found, we should re-populate the profile
if profile.status == 'invalid' and entity.status != 'invalid':
for prop_name in entity.properties():
value = getattr(entity, prop_name)
setattr(profile, prop_name, value)
if profile.student_info:
profile.student_info = None
if self.ROLE_FIELD:
# the role is either Mentor or OrgAdmin
getattr(profile, self.ROLE_FIELD).append(entity.scope.key())
else:
# the role is certainly Student; we have to create a new StudentInfo
properties = {}
for prop in POPULATED_STUDENT_PROPS:
properties[prop] = getattr(entity, prop)
key_name = profile.key().name()
student_info = StudentInfo(key_name=key_name,
parent=profile, **properties)
profile.student_info = student_info
to_put.append(student_info)
db.run_in_transaction(db.put, to_put)
def _process(self, start_key, batch_size):
"""Retrieves entities and creates or updates a corresponding
Profile entity.
"""
query = self.MODEL.all()
if start_key:
query.filter('__key__ > ', start_key)
try:
entities = query.fetch(batch_size)
if not entities:
# all entities has already been processed
return
for entity in entities:
try:
self._processEntity(entity)
except db.Error, e:
import logging
logging.exception(e)
logging.error("Broke on %s: %s" % (entity.key().name(), self.MODEL))
# process the next batch of entities
start_key = entities[-1].key()
deferred.defer(self._process, start_key, batch_size)
except DeadlineExceededError:
# here we should probably be more careful
deferred.defer(self._process, start_key, batch_size)
def updateHosts(request):
"""Starts a task which updates Host entities.
"""
updater = HostUpdater()
updater.run()
return http.HttpResponse("Ok")
def updateRole(role_name):
"""Starts a task which updates a particular role.
"""
if role_name == 'gsoc_mentor':
updater = RoleUpdater(GSoCMentor, GSoCProfile, 'program', 'mentor_for')
elif role_name == 'gsoc_org_admin':
updater = RoleUpdater(
GSoCOrgAdmin, GSoCProfile, 'program', 'org_admin_for')
elif role_name == 'gsoc_student':
updater = RoleUpdater(GSoCStudent, GSoCProfile, 'scope')
updater.run()
return http.HttpResponse("Ok")
def updateRoles(request):
"""Starts a bunch of iterative tasks which update particular roles.
In order to prevent issues with concurrent access to entities, we set
ETA so that each role is processed in separation.
"""
# update org admins
#updateRole('gsoc_org_admin')
# update mentors
#updateRole('gsoc_mentor')
# update students
# we can assume that students cannot have any other roles, so we do not
# need to set ETA
updateRole('gsoc_student')
def updateMentors(request):
"""Starts an iterative task which update mentors.
"""
return updateRole('gsoc_mentor')
def updateOrgAdmins(request):
"""Starts an iterative task which update org admins.
"""
return updateRole('gsoc_org_admin')
def updateStudents(request):
"""Starts an iterative task which update students.
"""
return updateRole('gsoc_student')
def _getProfileForRole(entity, profile_model):
"""Returns GSoCProfile or GCIProfile which corresponds to the specified
entity.
"""
if isinstance(entity, profile_model):
return entity
if isinstance(entity, OrgAdmin) or isinstance(entity, Mentor):
key_name = entity.program.key().name() + '/' + entity.user.key().name()
else:
key_name = entity.key().name()
parent = entity.user
return profile_model.get_by_key_name(key_name, parent=parent)
def _getProfileKeyForRoleKey(key, profile_model):
"""Returns Key instance of the Profile which corresponds to the Role which
is represented by the specified Key.
"""
entity = db.get(key)
profile = _getProfileForRole(entity, profile_model)
return profile.key()
class ReferenceUpdater(object):
"""Class which is responsible for updating references to Profile in
the specified model.
"""
def __init__(self, model, profile_model, fields_to_update,
lists_to_update=[]):
self.MODEL = model
self.PROFILE_MODEL = profile_model
self.FIELDS_TO_UPDATE = fields_to_update
self.LISTS_TO_UPDATE = lists_to_update
def run(self, batch_size=25):
"""Starts the updater.
"""
self._process(None, batch_size)
def _process(self, start_key | sponsor = entity.scope
host_for = entity.user.host_for
if not host_for:
host_for = []
user = entity.user
if sponsor.key() not in host_for:
host_for.append(sponsor.key())
user.host_for = host_for
db.put(user) | conditional_block |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.