_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q7000 | Logger.subscribe | train | def subscribe(self, queue=None, *levels):
"""
Subscribe to the aggregated log stream. On subscribe a ledis queue will be fed with all running processes
logs. Always use the returned queue name from this method, even if u specified the queue name to use
Note: it is legal to subscribe to the same queue, | python | {
"resource": ""
} |
q7001 | AggregatorManager.query | train | def query(self, key=None, **tags):
"""
Query zero-os aggregator for current state object of monitored metrics.
Note: ID is returned as part of the key (if set) to avoid conflict with similar metrics that
has same key. For example, a cpu core nr can be the id associated with 'machine.CPU.percent'
so we can return all values for all the core numbers in the same dict.
U can filter on the ID as a tag
:example:
self.query(key=key, id=value)
:param key: metric key (ex: machine.memory.ram.available)
| python | {
"resource": ""
} |
q7002 | CGroupManager.ensure | train | def ensure(self, subsystem, name):
"""
Creates a cgroup if it doesn't exist under the specified subsystem
and the given name
:param subsystem: the cgroup subsystem (currently support 'memory', and 'cpuset')
:param name: name of the cgroup to delete
"""
| python | {
"resource": ""
} |
q7003 | dlmk | train | def dlmk(l,m,k,theta1):
"""
returns value of d^l_mk as defined in allen, ottewill 97.
Called by Dlmk
"""
if m >= k:
factor = sqrt(factorial(l-k)*factorial(l+m)/factorial(l+k)/factorial(l-m))
part2 = (cos(theta1/2))**(2*l+k-m)*(-sin(theta1/2))**(m-k)/factorial(m-k)
| python | {
"resource": ""
} |
q7004 | Dlmk | train | def Dlmk(l,m,k,phi1,phi2,theta1,theta2):
"""
returns value of D^l_mk as defined in allen, ottewill 97.
"""
| python | {
"resource": ""
} |
q7005 | gamma | train | def gamma(phi1,phi2,theta1,theta2):
"""
calculate third rotation angle
inputs are angles from 2 pulsars
returns the angle.
"""
if phi1 == phi2 and theta1 == theta2:
gamma = 0
else:
gamma = atan( sin(theta2)*sin(phi2-phi1) / \
(cos(theta1)*sin(theta2)*cos(phi1-phi2) - \
| python | {
"resource": ""
} |
q7006 | rotated_Gamma_ml | train | def rotated_Gamma_ml(m,l,phi1,phi2,theta1,theta2,gamma_ml):
"""
This function takes any gamma in the computational frame and rotates it to the
cosmic frame.
"""
rotated_gamma = 0
| python | {
"resource": ""
} |
q7007 | real_rotated_Gammas | train | def real_rotated_Gammas(m,l,phi1,phi2,theta1,theta2,gamma_ml):
"""
This function returns the real-valued form of the Overlap Reduction Functions,
see Eqs 47 in Mingarelli et al, 2013.
"""
if m>0:
ans=(1./sqrt(2))*(rotated_Gamma_ml(m,l,phi1,phi2,theta1,theta2,gamma_ml) + \
| python | {
"resource": ""
} |
q7008 | chisq | train | def chisq(psr,formbats=False):
"""Return the total chisq for the current timing solution,
removing noise-averaged mean residual, and ignoring deleted points."""
if formbats:
psr.formbats() | python | {
"resource": ""
} |
q7009 | dchisq | train | def dchisq(psr,formbats=False,renormalize=True):
"""Return gradient of total chisq for the current timing solution,
after removing noise-averaged mean residual, and ignoring deleted points."""
if formbats:
psr.formbats()
res, err = psr.residuals(removemean=False)[psr.deleted == 0], psr.toaerrs[psr.deleted == 0]
res -= numpy.sum(res/err**2) / numpy.sum(1/err**2)
# bats already updated by residuals(); skip constant-phase column
M = psr.designmatrix(updatebats=False,fixunits=True,fixsigns=True)[psr.deleted==0,1:] | python | {
"resource": ""
} |
q7010 | create_fourier_design_matrix | train | def create_fourier_design_matrix(t, nmodes, freq=False, Tspan=None,
logf=False, fmin=None, fmax=None):
"""
Construct fourier design matrix from eq 11 of Lentati et al, 2013
:param t: vector of time series in seconds
:param nmodes: number of fourier coefficients to use
:param freq: option to output frequencies
:param Tspan: option to some other Tspan
:param logf: use log frequency spacing
:param fmin: lower sampling frequency
:param fmax: upper sampling frequency
:return: F: fourier design matrix
:return: f: Sampling frequencies (if freq=True)
"""
N = len(t)
F = np.zeros((N, 2 * nmodes))
if Tspan is not None:
T = Tspan
else:
| python | {
"resource": ""
} |
q7011 | powerlaw | train | def powerlaw(f, log10_A=-16, gamma=5):
"""Power-law PSD.
:param f: Sampling frequencies
:param log10_A: log10 of red noise Amplitude [GW units]
:param gamma: Spectral index of red noise process
| python | {
"resource": ""
} |
q7012 | add_gwb | train | def add_gwb(psr, dist=1, ngw=1000, seed=None, flow=1e-8, fhigh=1e-5,
gwAmp=1e-20, alpha=-0.66, logspacing=True):
"""Add a stochastic background from inspiraling binaries, using the tempo2
code that underlies the GWbkgrd plugin.
Here 'dist' is the pulsar distance [in kpc]; 'ngw' is the number of binaries,
'seed' (a negative integer) reseeds the GWbkgrd pseudorandom-number-generator,
| python | {
"resource": ""
} |
q7013 | add_dipole_gwb | train | def add_dipole_gwb(psr, dist=1, ngw=1000, seed=None, flow=1e-8,
fhigh=1e-5, gwAmp=1e-20, alpha=-0.66,
logspacing=True, dipoleamps=None,
dipoledir=None, dipolemag=None):
"""Add a stochastic background from inspiraling binaries distributed
according to a pure dipole distribution, using the tempo2
code that underlies the GWdipolebkgrd plugin.
The basic use is identical to that of 'add_gwb':
Here 'dist' is the pulsar distance [in kpc]; 'ngw' is the number of binaries,
'seed' (a negative integer) reseeds the GWbkgrd pseudorandom-number-generator,
'flow' and 'fhigh' [Hz] determine the background band, 'gwAmp' and 'alpha'
determine its amplitude and exponent, and setting 'logspacing' to False
will use linear spacing for the individual sources.
Additionally, the dipole component can be specified by using one of two
methods:
1) Specify the dipole direction as | python | {
"resource": ""
} |
q7014 | add_efac | train | def add_efac(psr, efac=1.0, flagid=None, flags=None, seed=None):
"""Add nominal TOA errors, multiplied by `efac` factor.
Optionally take a pseudorandom-number-generator seed."""
if seed is not None:
N.random.seed(seed)
# default efacvec
efacvec = N.ones(psr.nobs)
# check that efac is scalar if flags is None
if flags is None:
if not N.isscalar(efac):
raise ValueError('ERROR: If flags is None, efac must be a scalar')
else:
efacvec = N.ones(psr.nobs) * efac
if flags is not None | python | {
"resource": ""
} |
q7015 | extrap1d | train | def extrap1d(interpolator):
"""
Function to extend an interpolation function to an
extrapolation function.
:param interpolator: scipy interp1d object
:returns ufunclike: extension of function to extrapolation
"""
xs = interpolator.x
| python | {
"resource": ""
} |
q7016 | computeORFMatrix | train | def computeORFMatrix(psr):
"""
Compute ORF matrix.
:param psr: List of pulsar object instances
:returns: Matrix that has the ORF values for every pulsar
pair with 2 on the diagonals to account for the
pulsar term.
"""
# begin loop over all pulsar pairs and calculate ORF
npsr = len(psr)
ORF = N.zeros((npsr, npsr))
phati = N.zeros(3)
phatj = N.zeros(3)
ptheta = [N.pi/2 - p['DECJ'].val for p in psr]
pphi = [p['RAJ'].val for p in psr]
for ll in range(0, npsr):
phati[0] = N.cos(pphi[ll]) * N.sin(ptheta[ll])
phati[1] = N.sin(pphi[ll]) * N.sin(ptheta[ll])
phati[2] = N.cos(ptheta[ll])
for | python | {
"resource": ""
} |
q7017 | plotres | train | def plotres(psr,deleted=False,group=None,**kwargs):
"""Plot residuals, compute unweighted rms residual."""
res, t, errs = psr.residuals(), psr.toas(), psr.toaerrs
if (not deleted) and N.any(psr.deleted != 0):
res, t, errs = res[psr.deleted == 0], t[psr.deleted == 0], errs[psr.deleted == 0]
print("Plotting {0}/{1} nondeleted points.".format(len(res),psr.nobs))
meanres = math.sqrt(N.mean(res**2)) / 1e-6
if group is None:
i = N.argsort(t)
P.errorbar(t[i],res[i]/1e-6,yerr=errs[i],fmt='x',**kwargs)
else:
if (not deleted) and N.any(psr.deleted):
flagmask = psr.flagvals(group)[~psr.deleted]
else:
flagmask = psr.flagvals(group)
| python | {
"resource": ""
} |
q7018 | plotgwsrc | train | def plotgwsrc(gwb):
"""
Plot a GWB source population as a mollweide projection.
"""
theta, phi, omega, polarization = gwb.gw_dist()
rho = phi-N.pi
eta = 0.5*N.pi - theta
# I don't know how to get rid of the RuntimeWarning -- RvH, Oct 10, 2014:
# | python | {
"resource": ""
} |
q7019 | merge | train | def merge(data,skip=50,fraction=1.0):
"""Merge one every 'skip' clouds into a single emcee population,
using the later 'fraction' of the | python | {
"resource": ""
} |
q7020 | cull | train | def cull(data,index,min=None,max=None):
"""Sieve an emcee clouds by excluding walkers with search variable 'index'
smaller than 'min' | python | {
"resource": ""
} |
q7021 | make_ecc_interpolant | train | def make_ecc_interpolant():
"""
Make interpolation function from eccentricity file to
determine number of harmonics to use for a given
eccentricity.
:returns: interpolant
"""
pth = | python | {
"resource": ""
} |
q7022 | best_kmers | train | def best_kmers(dt, response, sequence, k=6, consider_shift=True, n_cores=1,
seq_align="start", trim_seq_len=None):
"""
Find best k-mers for CONCISE initialization.
Args:
dt (pd.DataFrame): Table containing response variable and sequence.
response (str): Name of the column used as the reponse variable.
sequence (str): Name of the column storing the DNA/RNA sequences.
k (int): Desired k-mer length.
n_cores (int): Number of cores to use for computation. It can use up to 3 cores.
consider_shift (boolean): When performing stepwise k-mer selection. Is TATTTA similar to ATTTAG?
seq_align (str): one of ``{"start", "end"}``. To which end should we align sequences?
trim_seq_len (int): Consider only first `trim_seq_len` bases of each sequence when generating the sequence design matrix. If :python:`None`, set :py:attr:`trim_seq_len` to the longest sequence length, hence whole sequences are considered.
Returns:
string list: Best set of motifs for this dataset sorted with respect to
confidence (best candidate occuring first).
Details:
First a lasso model gets fitted to get a set of initial motifs. Next, the best
subset of unrelated motifs is selected by stepwise selection.
"""
y = dt[response]
seq = dt[sequence]
if trim_seq_len is not None:
seq = pad_sequences(seq, align=seq_align, maxlen=trim_seq_len)
seq = [s.replace("N", "") for s in seq]
dt_kmer = kmer_count(seq, k)
Xsp = csc_matrix(dt_kmer)
en = ElasticNet(alpha=1, standardize=False, n_splits=3)
en.fit(Xsp, y)
# which coefficients are nonzero?=
nonzero_kmers = dt_kmer.columns.values[en.coef_ != 0].tolist()
# perform stepwise selection
#
# TODO - how do we deal with the intercept?
# largest number of motifs where they don't differ by more than 1 k-mer
| python | {
"resource": ""
} |
q7023 | kmer_count | train | def kmer_count(seq_list, k):
"""
Generate k-mer counts from a set of sequences
Args:
seq_list (iterable): List of DNA sequences (with letters from {A, C, G, T})
k (int): K in k-mer.
Returns:
pandas.DataFrame: Count matrix for seach sequence in seq_list
Example:
>>> kmer_count(["ACGTTAT", "GACGCGA"], 2)
AA AC AG AT CA CC CG CT GA GC GG GT TA TC TG TT
0 0 1 0 1 0 0 1 0 0 0 0 1 1 0 0 1
1 0 1 0 0 0 0 2 0 2 1 0 0 0 0 0 0 | python | {
"resource": ""
} |
q7024 | generate_all_kmers | train | def generate_all_kmers(k):
"""
Generate all possible k-mers
Example:
>>> generate_all_kmers(2)
['AA', 'AC', 'AG', 'AT', 'CA', 'CC', 'CG', 'CT', 'GA', 'GC', 'GG', 'GT', 'TA', 'TC', 'TG', 'TT']
| python | {
"resource": ""
} |
q7025 | dict_to_numpy_dict | train | def dict_to_numpy_dict(obj_dict):
"""
Convert a dictionary of lists into a dictionary of | python | {
"resource": ""
} |
q7026 | rec_dict_to_numpy_dict | train | def rec_dict_to_numpy_dict(obj_dict):
"""
Same as dict_to_numpy_dict, but recursive
"""
if type(obj_dict) == dict:
| python | {
"resource": ""
} |
q7027 | compare_numpy_dict | train | def compare_numpy_dict(a, b, exact=True):
"""
Compare two recursive numpy dictionaries
"""
if type(a) != type(b) and type(a) != np.ndarray and type(b) != np.ndarray:
return False
# go through a dictionary
if type(a) == dict and type(b) == dict:
if not a.keys() == b.keys():
return False
for key in a.keys():
res = compare_numpy_dict(a[key], b[key], exact)
if res == False:
print("false for key = ", key)
| python | {
"resource": ""
} |
q7028 | BSpline.getS | train | def getS(self, add_intercept=False):
"""Get the penalty matrix S
Returns
np.array, of shape (n_bases + add_intercept, n_bases + add_intercept)
"""
S = self.S
if add_intercept is True:
# S <- cbind(0, | python | {
"resource": ""
} |
q7029 | get_pwm_list | train | def get_pwm_list(motif_name_list, pseudocountProb=0.0001):
"""Get a list of ENCODE PWM's.
# Arguments
pwm_id_list: List of id's from the `PWM_id` column in `get_metadata()` table
pseudocountProb: Added pseudocount probabilities to the PWM
# Returns
List of `concise.utils.pwm.PWM` instances.
"""
| python | {
"resource": ""
} |
q7030 | auc | train | def auc(y_true, y_pred, round=True):
"""Area under the ROC curve
"""
y_true, y_pred = _mask_value_nan(y_true, y_pred)
if round:
y_true = | python | {
"resource": ""
} |
q7031 | recall_at_precision | train | def recall_at_precision(y_true, y_pred, precision):
"""Recall at a certain precision threshold
Args:
y_true: true labels
y_pred: predicted labels
precision: resired precision level at which where to compute the recall
"""
| python | {
"resource": ""
} |
q7032 | cor | train | def cor(y_true, y_pred):
"""Compute Pearson correlation coefficient.
"""
| python | {
"resource": ""
} |
q7033 | kendall | train | def kendall(y_true, y_pred, nb_sample=100000):
"""Kendall's tau coefficient, Kendall rank correlation coefficient
"""
y_true, y_pred = _mask_nan(y_true, y_pred)
if len(y_true) > nb_sample:
idx = np.arange(len(y_true))
np.random.shuffle(idx)
| python | {
"resource": ""
} |
q7034 | mad | train | def mad(y_true, y_pred):
"""Median absolute deviation
""" | python | {
"resource": ""
} |
q7035 | mse | train | def mse(y_true, y_pred):
"""Mean squared error
"""
y_true, y_pred = _mask_nan(y_true, y_pred)
| python | {
"resource": ""
} |
q7036 | sample_params | train | def sample_params(params):
"""Randomly sample hyper-parameters stored in a dictionary on a predefined range and scale.
Useful for hyper-parameter random search.
Args:
params (dict): hyper-parameters to sample. Dictionary value-type parsing:
- :python:`[1e3, 1e7]` - uniformly sample on a **log10** scale from the interval :python:`(1e3,1e7)`
- :python:`(1, 10)` - uniformly sample on a **normal** scale from the interval :python:`(1,10)`
- :python:`{1, 2}` - sample from a **set** of values.
- :python:`1` - don't sample
Returns:
dict: Dictionary with the same keys as :py:attr:`params`, but with only one element as the value.
Examples:
>>> myparams = {
"max_pool": True, # allways use True
"step_size": [0.09, 0.005],
"step_decay": (0.9, 1),
"n_splines": {10, None}, # use either 10 or None
"some_tuple": {(1,2), (1)},
}
>>> concise.sample_params(myparams)
{'step_decay': 0.9288, 'step_size': 0.0292, 'max_pool': True, 'n_splines': None, 'some_tuple': (1, 2)}
>>> concise.sample_params(myparams)
{'step_decay': 0.9243, 'step_size': 0.0293, 'max_pool': True, 'n_splines': None, 'some_tuple': (1)}
>>> concise.sample_params(myparams)
{'step_decay': 0.9460, 'step_size': 0.0301, 'max_pool': True, 'n_splines': 10, 'some_tuple': (1, 2)}
Note:
- :python:`{[1,2], [3,4]}` is invalid. Use :python:`{(1,2), (3,4)}` instead.
| python | {
"resource": ""
} |
q7037 | cat_acc | train | def cat_acc(y, z):
"""Classification accuracy for multi-categorical case
"""
weights = _cat_sample_weights(y)
_acc = | python | {
"resource": ""
} |
q7038 | split_KFold_idx | train | def split_KFold_idx(train, cv_n_folds=5, stratified=False, random_state=None):
"""Get k-fold indices generator
"""
test_len(train)
y = train[1]
n_rows = y.shape[0]
if stratified:
if len(y.shape) > 1:
if y.shape[1] > 1:
raise ValueError("Can't use stratified K-fold with multi-column response variable")
else:
y = y[:, 0]
| python | {
"resource": ""
} |
q7039 | prepare_data | train | def prepare_data(dt, features, response, sequence, id_column=None, seq_align="end", trim_seq_len=None):
"""
Prepare data for Concise.train or ConciseCV.train.
Args:
dt: A pandas DataFrame containing all the required data.
features (List of strings): Column names of `dt` used to produce the features design matrix. These columns should be numeric.
response (str or list of strings): Name(s) of column(s) used as a reponse variable.
sequence (str): Name of the column storing the DNA/RNA sequences.
id_column (str): Name of the column used as the row identifier.
seq_align (str): one of ``{"start", "end"}``. To which end should we align sequences?
trim_seq_len (int): Consider only first `trim_seq_len` bases of each sequence when generating the sequence design matrix. If :python:`None`, set :py:attr:`trim_seq_len` to the longest sequence length, hence whole sequences are considered.
standardize_features (bool): If True, column in the returned matrix matrix :py:attr:`X_seq` are normalied to have zero mean and unit variance.
Returns:
tuple: Tuple with elements: :code:`(X_feat: X_seq, y, id_vec)`, where:
- :py:attr:`X_feat`: features design matrix of shape :code:`(N, D)`, where N is :code:`len(dt)` and :code:`D = len(features)`
- :py:attr:`X_seq`: sequence matrix of shape :code:`(N, 1, trim_seq_len, 4)`. It represents 1-hot encoding of the DNA/RNA sequence.
- :py:attr:`y`: Response variable 1-column matrix of shape :code:`(N, 1)`
| python | {
"resource": ""
} |
q7040 | EncodeSplines.fit | train | def fit(self, x):
"""Calculate the knot placement from the values ranges.
# Arguments
x: numpy array, either N x D or N x L x D dimensional.
"""
assert x.ndim > 1
self.data_min_ = np.min(x, axis=tuple(range(x.ndim - 1)))
| python | {
"resource": ""
} |
q7041 | EncodeSplines.transform | train | def transform(self, x, warn=True):
"""Obtain the transformed values
"""
# 1. split across last dimension
# 2. re-use ranges
# 3. Merge
array_list = [encodeSplines(x[..., i].reshape((-1, 1)),
n_bases=self.n_bases,
spline_order=self.degree,
| python | {
"resource": ""
} |
q7042 | InputCodon | train | def InputCodon(seq_length, ignore_stop_codons=True, name=None, **kwargs):
"""Input placeholder for array returned by `encodeCodon`
Note: The seq_length is divided by 3
Wrapper for: `keras.layers.Input((seq_length | python | {
"resource": ""
} |
q7043 | InputAA | train | def InputAA(seq_length, name=None, **kwargs):
"""Input placeholder for array returned by `encodeAA`
Wrapper for: `keras.layers.Input((seq_length, 22), | python | {
"resource": ""
} |
q7044 | InputRNAStructure | train | def InputRNAStructure(seq_length, name=None, **kwargs):
"""Input placeholder for array returned by `encodeRNAStructure`
Wrapper for: `keras.layers.Input((seq_length, 5), | python | {
"resource": ""
} |
q7045 | ConvSequence._plot_weights_heatmap | train | def _plot_weights_heatmap(self, index=None, figsize=None, **kwargs):
"""Plot weights as a heatmap
index = can be a particular index or a list of indicies
**kwargs - additional arguments to concise.utils.plot.heatmap
"""
W = self.get_weights()[0]
if index is None:
| python | {
"resource": ""
} |
q7046 | ConvSequence._plot_weights_motif | train | def _plot_weights_motif(self, index, plot_type="motif_raw",
background_probs=DEFAULT_BASE_BACKGROUND,
ncol=1,
figsize=None):
"""Index can only be a single int
"""
w_all = self.get_weights()
if len(w_all) == 0:
raise Exception("Layer needs to be initialized first")
W = w_all[0]
if index is None:
index = np.arange(W.shape[2])
if isinstance(index, int):
index = [index]
fig = plt.figure(figsize=figsize)
if plot_type == "motif_pwm" and plot_type in self.AVAILABLE_PLOTS:
arr = pssm_array2pwm_array(W, background_probs)
elif plot_type == "motif_raw" and | python | {
"resource": ""
} |
q7047 | ConvSequence.plot_weights | train | def plot_weights(self, index=None, plot_type="motif_raw", figsize=None, ncol=1, **kwargs):
"""Plot filters as heatmap or motifs
index = can be a particular index or a list of indicies
**kwargs - additional arguments to concise.utils.plot.heatmap
"""
if "heatmap" in self.AVAILABLE_PLOTS and plot_type == "heatmap":
return self._plot_weights_heatmap(index=index, figsize=figsize, ncol=ncol, **kwargs)
| python | {
"resource": ""
} |
q7048 | _check_pwm_list | train | def _check_pwm_list(pwm_list):
"""Check the input validity
"""
for pwm in pwm_list:
if not isinstance(pwm, PWM):
| python | {
"resource": ""
} |
q7049 | heatmap | train | def heatmap(w, vmin=None, vmax=None, diverge_color=False,
ncol=1,
plot_name=None, vocab=["A", "C", "G", "T"], figsize=(6, 2)):
"""Plot a heatmap from weight matrix w
vmin, vmax = z axis range
diverge_color = Should we use diverging colors?
plot_name = plot_title
vocab = vocabulary (corresponds to the first axis)
"""
# Generate y and x values from the dimension lengths
assert len(vocab) == w.shape[0]
plt_y = np.arange(w.shape[0] + 1) + 0.5
plt_x = np.arange(w.shape[1] + 1) - 0.5
z_min = w.min()
z_max = w.max()
if vmin is None:
vmin = z_min
if vmax is None:
vmax = z_max
if diverge_color:
color_map = plt.cm.RdBu
else:
color_map = plt.cm.Blues
fig = plt.figure(figsize=figsize)
# multiple axis
if len(w.shape) == 3:
#
n_plots = w.shape[2]
nrow = math.ceil(n_plots / ncol)
else:
n_plots = 1
nrow = 1
ncol = 1
for i in range(n_plots):
if len(w.shape) == 3:
w_cur = w[:, :, i]
else:
w_cur = w
ax = plt.subplot(nrow, | python | {
"resource": ""
} |
q7050 | add_letter_to_axis | train | def add_letter_to_axis(ax, let, col, x, y, height):
"""Add 'let' with position x,y and height height to matplotlib axis 'ax'.
"""
if len(let) == 2:
colors = [col, "white"]
elif len(let) == 1:
colors = [col]
else:
raise ValueError("3 or more Polygons are not supported")
for polygon, color in zip(let, colors):
new_polygon = affinity.scale(
| python | {
"resource": ""
} |
q7051 | seqlogo | train | def seqlogo(letter_heights, vocab="DNA", ax=None):
"""Make a logo plot
# Arguments
letter_heights: "motif length" x "vocabulary size" numpy array
Can also contain negative values.
vocab: str, Vocabulary name. Can be: DNA, RNA, AA, RNAStruct.
ax: matplotlib axis
"""
ax = ax or plt.gca()
assert letter_heights.shape[1] == len(VOCABS[vocab])
x_range = [1, letter_heights.shape[0]]
pos_heights = np.copy(letter_heights)
pos_heights[letter_heights < 0] = 0
neg_heights = np.copy(letter_heights)
neg_heights[letter_heights > 0] = 0
for | python | {
"resource": ""
} |
q7052 | get_cv_accuracy | train | def get_cv_accuracy(res):
"""
Extract the cv accuracy from the model
"""
ac_list = [(accuracy["train_acc_final"],
accuracy["test_acc_final"]
)
for accuracy, weights in res]
ac = np.array(ac_list)
perf = {
| python | {
"resource": ""
} |
q7053 | one_hot2string | train | def one_hot2string(arr, vocab):
"""Convert a one-hot encoded array back to string
"""
tokens = one_hot2token(arr)
indexToLetter | python | {
"resource": ""
} |
q7054 | tokenize | train | def tokenize(seq, vocab, neutral_vocab=[]):
"""Convert sequence to integers
# Arguments
seq: Sequence to encode
vocab: Vocabulary to use
neutral_vocab: Neutral vocabulary -> assign those values to -1
# Returns
List of length `len(seq)` with integers from `-1` to `len(vocab) - 1`
"""
# Req: all vocabs have | python | {
"resource": ""
} |
q7055 | encodeSequence | train | def encodeSequence(seq_vec, vocab, neutral_vocab, maxlen=None,
seq_align="start", pad_value="N", encode_type="one_hot"):
"""Convert a list of genetic sequences into one-hot-encoded array.
# Arguments
seq_vec: list of strings (genetic sequences)
vocab: list of chars: List of "words" to use as the vocabulary. Can be strings of length>0,
but all need to have the same length. For DNA, this is: ["A", "C", "G", "T"].
neutral_vocab: list of chars: Values used to pad the sequence or represent unknown-values. For DNA, this is: ["N"].
maxlen: int or None,
Should we trim (subset) the resulting sequence. If None don't trim.
Note that trims wrt the align parameter.
It should be smaller than the longest sequence.
seq_align: character; 'end' or 'start'
To which end should we align sequences?
encode_type: "one_hot" or "token". "token" represents each vocab element as a positive integer from 1 to len(vocab) + 1.
neutral_vocab is represented with 0.
# Returns
Array with shape for encode_type:
- "one_hot": `(len(seq_vec), maxlen, len(vocab))`
- "token": `(len(seq_vec), maxlen)`
If `maxlen=None`, it gets the value of the longest sequence length from `seq_vec`.
"""
if isinstance(neutral_vocab, str):
neutral_vocab = [neutral_vocab]
if isinstance(seq_vec, | python | {
"resource": ""
} |
q7056 | encodeDNA | train | def encodeDNA(seq_vec, maxlen=None, seq_align="start"):
"""Convert the DNA sequence into 1-hot-encoding numpy array
# Arguments
seq_vec: list of chars
List of sequences that can have different lengths
maxlen: int or None,
Should we trim (subset) the resulting sequence. If None don't trim.
Note that trims wrt the align parameter.
It should be smaller than the longest sequence.
seq_align: character; 'end' or 'start'
To which end should we align sequences?
# Returns
3D numpy array of shape (len(seq_vec), trim_seq_len(or maximal sequence length if None), 4)
# Example
| python | {
"resource": ""
} |
q7057 | encodeRNA | train | def encodeRNA(seq_vec, maxlen=None, seq_align="start"):
"""Convert the RNA sequence into 1-hot-encoding numpy array as for encodeDNA
"""
return encodeSequence(seq_vec,
vocab=RNA,
neutral_vocab="N",
| python | {
"resource": ""
} |
q7058 | encodeCodon | train | def encodeCodon(seq_vec, ignore_stop_codons=True, maxlen=None, seq_align="start", encode_type="one_hot"):
"""Convert the Codon sequence into 1-hot-encoding numpy array
# Arguments
seq_vec: List of strings/DNA sequences
ignore_stop_codons: boolean; if True, STOP_CODONS are omitted from one-hot encoding.
maxlen: Maximum sequence length. See `pad_sequences` for more detail
seq_align: How to align the sequences of variable lengths. See `pad_sequences` for more detail
encode_type: can be `"one_hot"` or `token` for token encoding of codons (incremental integer ).
# Returns
numpy.ndarray of shape `(len(seq_vec), maxlen / 3, 61 if ignore_stop_codons else 64)`
"""
if ignore_stop_codons:
vocab = CODONS
neutral_vocab = STOP_CODONS | python | {
"resource": ""
} |
q7059 | encodeAA | train | def encodeAA(seq_vec, maxlen=None, seq_align="start", encode_type="one_hot"):
"""Convert the Amino-acid sequence into 1-hot-encoding numpy array
# Arguments
seq_vec: List of strings/amino-acid sequences
maxlen: Maximum sequence length. See `pad_sequences` for more detail
seq_align: How to align the sequences of variable lengths. See `pad_sequences` for more detail
encode_type: can be `"one_hot"` or `token` for token encoding of codons (incremental integer ).
# Returns
| python | {
"resource": ""
} |
q7060 | _validate_pos | train | def _validate_pos(df):
"""Validates the returned positional object
"""
assert isinstance(df, pd.DataFrame)
assert ["seqname", "position", "strand"] == df.columns.tolist()
assert | python | {
"resource": ""
} |
q7061 | get_pwm_list | train | def get_pwm_list(pwm_id_list, pseudocountProb=0.0001):
"""Get a list of Attract PWM's.
# Arguments
pwm_id_list: List of id's from the `PWM_id` column in `get_metadata()` table
pseudocountProb: Added pseudocount probabilities to the PWM
# Returns
List of `concise.utils.pwm.PWM` instances.
"""
l = | python | {
"resource": ""
} |
q7062 | mask_loss | train | def mask_loss(loss, mask_value=MASK_VALUE):
"""Generates a new loss function that ignores values where `y_true == mask_value`.
# Arguments
loss: str; name of the keras loss function from `keras.losses`
mask_value: int; which values should be masked
# Returns
function; Masked version of the `loss`
# Example
```python
categorical_crossentropy_masked = mask_loss("categorical_crossentropy")
```
"""
loss_fn = kloss.deserialize(loss)
def masked_loss_fn(y_true, y_pred):
# currently not suppoerd with NA's:
# - there is no K.is_nan impolementation in keras.backend
# | python | {
"resource": ""
} |
q7063 | get_pwm_list | train | def get_pwm_list(pwm_id_list, pseudocountProb=0.0001):
"""Get a list of HOCOMOCO PWM's.
# Arguments
pwm_id_list: List of id's from the `PWM_id` column in `get_metadata()` table
pseudocountProb: Added pseudocount probabilities to the PWM
# Returns
List of `concise.utils.pwm.PWM` instances.
"""
l = | python | {
"resource": ""
} |
q7064 | Concise._var_res_to_weights | train | def _var_res_to_weights(self, var_res):
"""
Get model weights
"""
# transform the weights into our form
motif_base_weights_raw = var_res["motif_base_weights"][0]
motif_base_weights = np.swapaxes(motif_base_weights_raw, 0, 2)
# get weights
motif_weights = var_res["motif_weights"]
motif_bias = var_res["motif_bias"]
final_bias = var_res["final_bias"]
feature_weights = var_res["feature_weights"]
# get the GAM prediction:
spline_pred = None
spline_weights = | python | {
"resource": ""
} |
q7065 | Concise._get_var_res | train | def _get_var_res(self, graph, var, other_var):
"""
Get the weights from our graph
"""
with tf.Session(graph=graph) as sess:
sess.run(other_var["init"])
# all_vars = tf.all_variables()
# print("All variable names")
| python | {
"resource": ""
} |
q7066 | Concise._convert_to_var | train | def _convert_to_var(self, graph, var_res):
"""
Create tf.Variables from a list of numpy arrays
var_res: dictionary of numpy arrays with the key names corresponding to var
| python | {
"resource": ""
} |
q7067 | Concise.train | train | def train(self, X_feat, X_seq, y,
X_feat_valid=None, X_seq_valid=None, y_valid=None,
n_cores=3):
"""Train the CONCISE model
:py:attr:`X_feat`, :py:attr:`X_seq`, py:attr:`y` are preferrably returned by the :py:func:`concise.prepare_data` function.
Args:
X_feat: Numpy (float) array of shape :code:`(N, D)`. Feature design matrix storing :code:`N` training samples and :code:`D` features
X_seq: Numpy (float) array of shape :code:`(N, 1, N_seq, 4)`. It represents 1-hot encoding of the DNA/RNA sequence.(:code:`N`-seqeuences of length :code:`N_seq`)
y: Numpy (float) array of shape :code:`(N, 1)`. Response variable.
X_feat_valid: :py:attr:`X_feat` used for model validation.
X_seq_valid: :py:attr:`X_seq` used for model validation.
y: :py:attr:`y` used for model validation.
n_cores (int): Number of CPU cores used for training. If available, GPU is used for training and this argument is ignored.
"""
if X_feat_valid is None and X_seq_valid is None and y_valid is None:
X_feat_valid = X_feat
X_seq_valid = X_seq
y_valid = y
print("Using training samples also for validation ")
# insert one dimension - backcompatiblity
X_seq = np.expand_dims(X_seq, axis=1)
X_seq_valid = np.expand_dims(X_seq_valid, axis=1)
# TODO: implement the re-training feature
if self.is_trained() is True:
print("Model already fitted. Re-training feature not implemented yet")
return
# input check
assert X_seq.shape[0] == X_feat.shape[0] == y.shape[0]
assert y.shape == (X_feat.shape[0], self._num_tasks)
# extract data specific parameters
self._param["seq_length"] = X_seq.shape[2]
self._param["n_add_features"] = X_feat.shape[1]
# more input check
if not self._param["seq_length"] == X_seq_valid.shape[2]:
raise Exception("sequence lengths don't match")
# setup splines
if self._param["n_splines"] is not None:
padd_loss = self._param["motif_length"] - 1 # how much shorter is our sequence, since we don't use padding
X_spline, S, _ = splines.get_gam_splines(start=0,
end=self._param["seq_length"] - padd_loss - 1, # -1 due to zero-indexing
| python | {
"resource": ""
} |
q7068 | Concise._accuracy_in_session | train | def _accuracy_in_session(self, sess, other_var, X_feat, X_seq, y):
"""
Compute the accuracy from inside the tf session
"""
| python | {
"resource": ""
} |
q7069 | Concise._set_var_res | train | def _set_var_res(self, weights):
"""
Transform the weights to var_res
"""
if weights is None:
return
# layer 1
motif_base_weights_raw = np.swapaxes(weights["motif_base_weights"], 2, 0)
motif_base_weights = motif_base_weights_raw[np.newaxis]
motif_bias = weights["motif_bias"]
feature_weights = weights["feature_weights"]
spline_weights = weights["spline_weights"]
# filter
motif_weights = weights["motif_weights"]
final_bias = weights["final_bias"]
var_res = {
"motif_base_weights": motif_base_weights,
| python | {
"resource": ""
} |
q7070 | ConciseCV._get_folds | train | def _get_folds(n_rows, n_folds, use_stored):
"""
Get the used CV folds
"""
# n_folds = self._n_folds
# use_stored = self._use_stored_folds
# n_rows = self._n_rows
if use_stored is not None:
# path = '~/concise/data-offline/lw-pombe/cv_folds_5.json'
with open(os.path.expanduser(use_stored)) as json_file:
json_data = json.load(json_file)
# check if we have the same number of rows and folds:
if json_data['N_rows'] != n_rows:
raise Exception('N_rows from folds doesnt match the number of rows of X_seq, X_feat, y')
if json_data['N_folds'] != n_folds:
| python | {
"resource": ""
} |
q7071 | ConciseCV.train | train | def train(self, X_feat, X_seq, y, id_vec=None, n_folds=10, use_stored_folds=None, n_cores=1,
train_global_model=False):
"""Train the Concise model in cross-validation.
Args:
X_feat: See :py:func:`concise.Concise.train`
X_seq: See :py:func:`concise.Concise.train`
y: See :py:func:`concise.Concise.train`
id_vec: List of character id's used to differentiate the trainig samples. Returned by :py:func:`concise.prepare_data`.
n_folds (int): Number of CV-folds to use.
use_stored_folds (chr or None): File path to a .json file containing the fold information (as returned by :py:func:`concise.ConciseCV.get_folds`). If None, the folds are generated.
n_cores (int): Number of CPU cores used for training. If available, GPU is used for training and this argument is ignored.
train_global_model (bool): In addition to training the model in cross-validation, should the global model be fitted (using all the samples from :code:`(X_feat, X_seq, y)`).
"""
# TODO: input check - dimensions
self._use_stored_folds = use_stored_folds
self._n_folds = n_folds
self._n_rows = X_feat.shape[0]
# TODO: - fix the get_cv_accuracy
# save:
# - each model
# - each model's performance
# - each model's predictions
# - globally:
# - mean perfomance
# - sd performance
# - predictions
self._kf = self._get_folds(self._n_rows, self._n_folds, self._use_stored_folds)
cv_obj = {}
if id_vec is None:
id_vec = np.arange(1, self._n_rows + 1)
best_val_acc_epoch_l = []
for fold, train, test in self._kf:
X_feat_train = X_feat[train]
X_seq_train = X_seq[train]
y_train = y[train]
X_feat_test = X_feat[test]
X_seq_test = X_seq[test]
y_test = y[test]
id_vec_test = id_vec[test]
print(fold, "/", n_folds)
| python | {
"resource": ""
} |
q7072 | ConciseCV._from_dict | train | def _from_dict(self, obj_dict):
"""
Initialize a model from the dictionary
"""
self._n_folds = obj_dict["param"]["n_folds"]
self._n_rows = obj_dict["param"]["n_rows"]
self._use_stored_folds = obj_dict["param"]["use_stored_folds"]
self._concise_model = Concise.from_dict(obj_dict["init_model"])
if obj_dict["trained_global_model"] is None:
self._concise_global_model = None
| python | {
"resource": ""
} |
q7073 | pwm_array2pssm_array | train | def pwm_array2pssm_array(arr, background_probs=DEFAULT_BASE_BACKGROUND):
"""Convert pwm array to | python | {
"resource": ""
} |
q7074 | pssm_array2pwm_array | train | def pssm_array2pwm_array(arr, background_probs=DEFAULT_BASE_BACKGROUND):
"""Convert pssm array to | python | {
"resource": ""
} |
q7075 | load_motif_db | train | def load_motif_db(filename, skipn_matrix=0):
"""Read the motif file in the following format
```
>motif_name
<skip n>0.1<delim>0.2<delim>0.5<delim>0.6
...
>motif_name2
....
```
Delim can be anything supported by np.loadtxt
# Arguments
filename: str, file path
skipn_matrix: integer, number of characters to skip when reading
the numeric matrix (for Encode = 2)
# Returns
Dictionary of numpy arrays
"""
# read-lines
if filename.endswith(".gz"):
f = gzip.open(filename, 'rt', encoding='utf-8')
else:
f = open(filename, 'r')
lines = f.readlines()
f.close()
motifs_dict = {}
motif_lines = ""
motif_name = None
def lines2matrix(lines): | python | {
"resource": ""
} |
q7076 | iter_fasta | train | def iter_fasta(file_path):
"""Returns an iterator over the fasta file
Given a fasta file. yield tuples of header, sequence
Code modified from Brent Pedersen's:
"Correct Way To Parse A Fasta File In Python"
# Example
```python
fasta = fasta_iter("hg19.fa")
for header, seq in fasta:
print(header)
```
"""
fh = open(file_path)
# ditch the boolean (x[0]) and just keep the header or sequence since
# we know they alternate.
faiter = (x[1] | python | {
"resource": ""
} |
q7077 | write_fasta | train | def write_fasta(file_path, seq_list, name_list=None):
"""Write a fasta file
# Arguments
file_path: file path
seq_list: List of strings
name_list: List of names corresponding to the sequences.
If not None, it should have the same length as `seq_list`
"""
if name_list is None:
| python | {
"resource": ""
} |
q7078 | read_RNAplfold | train | def read_RNAplfold(tmpdir, maxlen=None, seq_align="start", pad_with="E"):
"""
pad_with = with which 2ndary structure should we pad the sequence?
"""
assert pad_with in {"P", "H", "I", "M", "E"}
def read_profile(tmpdir, P):
return [values.strip().split("\t")
for seq_name, values in iter_fasta("{tmp}/{P}_profile.fa".format(tmp=tmpdir, P=P))]
def nelem(P, pad_width):
"""get the right neutral element
"""
return 1 if P is pad_with else 0
arr_hime = np.array([pad_sequences(read_profile(tmpdir, P),
value=[nelem(P, pad_with)],
align=seq_align,
| python | {
"resource": ""
} |
q7079 | ism | train | def ism(model, ref, ref_rc, alt, alt_rc, mutation_positions, out_annotation_all_outputs,
output_filter_mask=None, out_annotation=None, diff_type="log_odds", rc_handling="maximum"):
"""In-silico mutagenesis
Using ISM in with diff_type 'log_odds' and rc_handling 'maximum' will produce predictions as used
in [DeepSEA](http://www.nature.com/nmeth/journal/v12/n10/full/nmeth.3547.html). ISM offers two ways to
calculate the difference between the outputs created by reference and alternative sequence and two
different methods to select whether to use the output generated from the forward or from the
reverse-complement sequences. To calculate "e-values" as mentioned in DeepSEA the same ISM prediction
has to be performed on a randomised set of 1 million 1000genomes, MAF-matched variants to get a
background of predicted effects of random SNPs.
# Arguments
model: Keras model
ref: Input sequence with the reference genotype in the mutation position
ref_rc: Reverse complement of the 'ref' argument
alt: Input sequence with the alternative genotype in the mutation position
alt_rc: Reverse complement of the 'alt' argument
mutation_positions: Position on which the mutation was placed in the forward sequences
out_annotation_all_outputs: Output labels of the model.
output_filter_mask: Mask of boolean values indicating which model outputs should be used.
Use this or 'out_annotation'
out_annotation: List of outputs labels for which of the outputs (in case of a multi-task model) the
predictions should be calculated.
diff_type: "log_odds" or "diff". When set to 'log_odds' calculate scores based on log_odds, which assumes
| python | {
"resource": ""
} |
q7080 | _train_and_eval_single | train | def _train_and_eval_single(train, valid, model,
batch_size=32, epochs=300, use_weight=False,
callbacks=[], eval_best=False, add_eval_metrics={}):
"""Fit and evaluate a keras model
eval_best: if True, load the checkpointed model for evaluation
"""
def _format_keras_history(history):
"""nicely format keras history
"""
return {"params": history.params,
"loss": merge_dicts({"epoch": history.epoch}, history.history),
| python | {
"resource": ""
} |
q7081 | eval_model | train | def eval_model(model, test, add_eval_metrics={}):
"""Evaluate model's performance on the test-set.
# Arguments
model: Keras model
test: test-dataset. Tuple of inputs `x` and target `y` - `(x, y)`.
add_eval_metrics: Additional evaluation metrics to use. Can be a dictionary or a list of functions
accepting arguments: `y_true`, `y_predicted`. Alternatively, you can provide names of functions from
the `concise.eval_metrics` module.
# Returns
dictionary with evaluation metrics
"""
# evaluate the model
logger.info("Evaluate...")
# - model_metrics
model_metrics_values = model.evaluate(test[0], test[1], verbose=0,
| python | {
"resource": ""
} |
q7082 | get_model | train | def get_model(model_fn, train_data, param):
"""Feed model_fn with train_data and param
"""
model_param = | python | {
"resource": ""
} |
q7083 | _delete_keys | train | def _delete_keys(dct, keys):
"""Returns a copy of dct without `keys` keys
| python | {
"resource": ""
} |
q7084 | _mean_dict | train | def _mean_dict(dict_list):
"""Compute the mean value across a list of dictionaries
| python | {
"resource": ""
} |
q7085 | CMongoTrials.get_trial | train | def get_trial(self, tid):
"""Retrieve trial by tid
"""
| python | {
"resource": ""
} |
q7086 | CMongoTrials.delete_running | train | def delete_running(self, timeout_last_refresh=0, dry_run=False):
"""Delete jobs stalled in the running state for too long
timeout_last_refresh, int: number of seconds
"""
running_all = self.handle.jobs_running()
running_timeout = [job for job in running_all
if coarse_utcnow() > job["refresh_time"] +
timedelta(seconds=timeout_last_refresh)]
if len(running_timeout) == 0:
# Nothing to stop
self.refresh_tids(None)
return None
if dry_run:
logger.warning("Dry run. Not removing anything.")
logger.info("Removing {0}/{1} running jobs. # all jobs: {2} ".
| python | {
"resource": ""
} |
q7087 | CMongoTrials.train_history | train | def train_history(self, tid=None):
"""Get train history as pd.DataFrame
"""
def result2history(result):
if isinstance(result["history"], list):
return pd.concat([pd.DataFrame(hist["loss"]).assign(fold=i)
for i, hist in enumerate(result["history"])])
else:
return pd.DataFrame(result["history"]["loss"])
# use all
if tid is None:
tid = self.valid_tid()
| python | {
"resource": ""
} |
q7088 | CMongoTrials.as_df | train | def as_df(self, ignore_vals=["history"], separator=".", verbose=True):
"""Return a pd.DataFrame view of the whole experiment
"""
def add_eval(res):
if "eval" not in res:
if isinstance(res["history"], list):
# take the average across all folds
eval_names = list(res["history"][0]["loss"].keys())
eval_metrics = np.array([[v[-1] for k, v in hist["loss"].items()]
for hist in res["history"]]).mean(axis=0).tolist()
res["eval"] = {eval_names[i]: eval_metrics[i] for i in range(len(eval_metrics))}
else:
res["eval"] = {k: v[-1] for k, v in | python | {
"resource": ""
} |
q7089 | effect_from_model | train | def effect_from_model(model, ref, ref_rc, alt, alt_rc, methods, mutation_positions, out_annotation_all_outputs,
extra_args=None, **argv):
"""Convenience function to execute multiple effect predictions in one call
# Arguments
model: Keras model
ref: Input sequence with the reference genotype in the mutation position
ref_rc: Reverse complement of the 'ref' argument
alt: Input sequence with the alternative genotype in the mutation position
alt_rc: Reverse complement of the 'alt' argument
methods: A list of prediction functions to be executed, e.g.: from concise.effects.ism.ism. Using the same
function more often than once (even with different parameters) will overwrite the results of the
previous calculation of that function.
mutation_positions: Position on which the mutation was placed in the forward sequences
out_annotation_all_outputs: Output labels of the model.
extra_args: None or a list of the same length as 'methods'. The elements of the list are dictionaries with
additional arguments that should be passed on to the respective functions in 'methods'. Arguments
defined here will overwrite arguments that are passed to all methods.
**argv: Additional arguments to be passed on to all methods, e.g,: out_annotation.
# Returns
Dictionary containing the results of the individual calculations, the keys are the
names of the executed functions
| python | {
"resource": ""
} |
q7090 | trades | train | def trades(ctx, market, limit, start, stop):
""" List trades in a market
"""
market = Market(market, bitshares_instance=ctx.bitshares)
t = [["time", "quote", "base", "price"]]
for trade in market.trades(limit, start=start, stop=stop):
t.append(
[
str(trade["time"]),
str(trade["quote"]),
str(trade["base"]),
| python | {
"resource": ""
} |
q7091 | ticker | train | def ticker(ctx, market):
""" Show ticker of a market
"""
market = Market(market, bitshares_instance=ctx.bitshares)
ticker = market.ticker()
t = [["key", "value"]]
| python | {
"resource": ""
} |
q7092 | cancel | train | def cancel(ctx, orders, account):
""" Cancel one or multiple orders
"""
| python | {
"resource": ""
} |
q7093 | orderbook | train | def orderbook(ctx, market):
""" Show the orderbook of a particular market
"""
market = Market(market, bitshares_instance=ctx.bitshares)
orderbook = market.orderbook()
ta = {}
ta["bids"] = [["quote", "sum quote", "base", "sum base", "price"]]
cumsumquote = Amount(0, market["quote"])
cumsumbase = Amount(0, market["base"])
for order in orderbook["bids"]:
cumsumbase += order["base"]
cumsumquote += order["quote"]
ta["bids"].append(
[
str(order["quote"]),
str(cumsumquote),
str(order["base"]),
str(cumsumbase),
"{:f} {}/{}".format(
order["price"],
order["base"]["asset"]["symbol"],
order["quote"]["asset"]["symbol"],
),
]
)
ta["asks"] = [["price", "base", "sum base", "quote", "sum quote"]]
cumsumquote = Amount(0, market["quote"])
cumsumbase = Amount(0, market["base"])
for order in orderbook["asks"]:
| python | {
"resource": ""
} |
q7094 | buy | train | def buy(ctx, buy_amount, buy_asset, price, sell_asset, order_expiration, account):
""" Buy a specific asset at a certain rate against a base asset
"""
amount = Amount(buy_amount, buy_asset)
price = Price(
| python | {
"resource": ""
} |
q7095 | openorders | train | def openorders(ctx, account):
""" List open orders of an account
"""
account = Account(
account or config["default_account"], bitshares_instance=ctx.bitshares
)
t = [["Price", "Quote", "Base", "ID"]]
for o in account.openorders:
t.append(
[
"{:f} {}/{}".format(
o["price"],
| python | {
"resource": ""
} |
q7096 | cancelall | train | def cancelall(ctx, market, account):
""" Cancel all orders of an account in a market
"""
market = Market(market)
| python | {
"resource": ""
} |
q7097 | spread | train | def spread(ctx, market, side, min, max, num, total, order_expiration, account):
""" Place multiple orders
\b
:param str market: Market pair quote:base (e.g. USD:BTS)
:param str side: ``buy`` or ``sell`` quote
:param float min: minimum price to place order at
:param float max: maximum price to place order at
:param int num: Number of orders to place
:param float total: Total amount of quote to use for all orders
:param int order_expiration: Number of seconds until the order expires from the books
"""
from tqdm import tqdm
from numpy import linspace
market = Market(market)
| python | {
"resource": ""
} |
q7098 | updateratio | train | def updateratio(ctx, symbol, ratio, account):
""" Update the collateral ratio of a call positions
"""
| python | {
"resource": ""
} |
q7099 | bidcollateral | train | def bidcollateral(
ctx, collateral_symbol, collateral_amount, debt_symbol, debt_amount, account
):
""" Bid for collateral in the settlement fund
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.