Search is not available for this dataset
text stringlengths 75 104k |
|---|
def _fitch_state(self, node, pos):
"""
Determine the Fitch profile for a single character of the node's sequence.
The profile is essentially the intersection between the children's
profiles or, if the former is empty, the union of the profiles.
Parameters
----------
... |
def _fitch_intersect(self, arrays):
"""
Find the intersection of any number of 1D arrays.
Return the sorted, unique values that are in all of the input arrays.
Adapted from numpy.lib.arraysetops.intersect1d
"""
def pairwise_intersect(arr1, arr2):
s2 = set(arr2... |
def sequence_LH(self, pos=None, full_sequence=False):
"""return the likelihood of the observed sequences given the tree
Parameters
----------
pos : int, optional
position in the sequence, if none, the sum over all positions will be returned
full_sequence : bool, opti... |
def ancestral_likelihood(self):
"""
Calculate the likelihood of the given realization of the sequences in
the tree
Returns
-------
log_lh : float
The tree likelihood given the sequences
"""
log_lh = np.zeros(self.multiplicity.shape[0])
... |
def _branch_length_to_gtr(self, node):
"""
Set branch lengths to either mutation lengths of given branch lengths.
The assigend values are to be used in the following ML analysis.
"""
if self.use_mutation_length:
return max(ttconf.MIN_BRANCH_LENGTH*self.one_mutation, n... |
def _ml_anc_marginal(self, store_compressed=False, final=True, sample_from_profile=False,
debug=False, **kwargs):
"""
Perform marginal ML reconstruction of the ancestral states. In contrast to
joint reconstructions, this needs to access the probabilities rather than only... |
def _ml_anc_joint(self, store_compressed=True, final=True, sample_from_profile=False,
debug=False, **kwargs):
"""
Perform joint ML reconstruction of the ancestral states. In contrast to
marginal reconstructions, this only needs to compare and multiply LH and
... |
def _store_compressed_sequence_to_node(self, node):
"""
make a compressed representation of a pair of sequences only counting
the number of times a particular pair of states (e.g. (A,T)) is observed
the the aligned sequences of parent and child.
Parameters
-----------
... |
def _store_compressed_sequence_pairs(self):
"""
Traverse the tree, and for each node store the compressed sequence pair.
**Note** sequence reconstruction should be performed prior to calling
this method.
"""
self.logger("TreeAnc._store_compressed_sequence_pairs...",2)
... |
def optimize_branch_length(self, mode='joint', **kwargs):
"""
Perform optimization for the branch lengths of the entire tree.
This method only does a single path and needs to be iterated.
**Note** this method assumes that each node stores information
about its sequence as numpy.... |
def optimize_branch_length_global(self, **kwargs):
"""
EXPERIMENTAL GLOBAL OPTIMIZATION
"""
self.logger("TreeAnc.optimize_branch_length_global: running branch length optimization...",1)
def neg_log(s):
for si, n in zip(s, self.tree.find_clades(order='preorder')):
... |
def optimal_branch_length(self, node):
'''
Calculate optimal branch length given the sequences of node and parent
Parameters
----------
node : PhyloTree.Clade
TreeNode, attached to the branch.
Returns
-------
new_len : float
Optimal... |
def marginal_branch_profile(self, node):
'''
calculate the marginal distribution of sequence states on both ends
of the branch leading to node,
Parameters
----------
node : PhyloTree.Clade
TreeNode, attached to the branch.
Returns
-------
... |
def optimal_marginal_branch_length(self, node, tol=1e-10):
'''
calculate the marginal distribution of sequence states on both ends
of the branch leading to node,
Parameters
----------
node : PhyloTree.Clade
TreeNode, attached to the branch.
Returns
... |
def prune_short_branches(self):
"""
If the branch length is less than the minimal value, remove the branch
from the tree. **Requires** ancestral sequence reconstruction
"""
self.logger("TreeAnc.prune_short_branches: pruning short branches (max prob at zero)...", 1)
for no... |
def optimize_seq_and_branch_len(self,reuse_branch_len=True, prune_short=True,
marginal_sequences=False, branch_length_mode='joint',
max_iter=5, infer_gtr=False, **kwargs):
"""
Iteratively set branch lengths and reconstruct ancestral... |
def get_reconstructed_alignment(self):
"""
Get the multiple sequence alignment, including reconstructed sequences for
the internal nodes.
Returns
-------
new_aln : MultipleSeqAlignment
Alignment including sequences of all internal nodes
"""
fr... |
def get_tree_dict(self, keep_var_ambigs=False):
"""
For VCF-based objects, returns a nested dict with all the information required to
reconstruct sequences for all nodes (terminal and internal).
Parameters
----------
keep_var_ambigs : boolean
If true, generat... |
def Q(self):
"""function that return the product of the transition matrix
and the equilibrium frequencies to obtain the rate matrix
of the GTR model
"""
tmp = np.einsum('ia,ij->ija', self.Pi, self.W)
diag_vals = np.sum(tmp, axis=0)
for x in range(tmp.shape[-... |
def assign_rates(self, mu=1.0, pi=None, W=None):
"""
Overwrite the GTR model given the provided data
Parameters
----------
mu : float
Substitution rate
W : nxn matrix
Substitution matrix
pi : n vector
Equilibrium frequenc... |
def random(cls, L=1, avg_mu=1.0, alphabet='nuc', pi_dirichlet_alpha=1,
W_dirichlet_alpha=3.0, mu_gamma_alpha=3.0):
"""
Creates a random GTR model
Parameters
----------
mu : float
Substitution rate
alphabet : str
Alphabet name (s... |
def custom(cls, mu=1.0, pi=None, W=None, **kwargs):
"""
Create a GTR model by specifying the matrix explicitly
Parameters
----------
mu : float
Substitution rate
W : nxn matrix
Substitution matrix
pi : n vector
Equilibriu... |
def infer(cls, sub_ija, T_ia, root_state, pc=0.01,
gap_limit=0.01, Nit=30, dp=1e-5, **kwargs):
"""
Infer a GTR model by specifying the number of transitions and time spent in each
character. The basic equation that is being solved is
:math:`n_{ij} = pi_i W_{ij} T_j`
... |
def prob_t(self, seq_p, seq_ch, t, pattern_multiplicity = None,
return_log=False, ignore_gaps=True):
"""
Compute the probability to observe seq_ch (child sequence) after time t starting from seq_p
(parent sequence).
Parameters
----------
seq_p : characte... |
def assign_rates(self, mu=1.0, pi=None, W=None):
"""
Overwrite the GTR model given the provided data
Parameters
----------
mu : float
Substitution rate
W : nxn matrix
Substitution matrix
pi : n vector
Equilibrium frequenc... |
def standard(model, **kwargs):
"""
Create standard model of molecular evolution.
Parameters
----------
model : str
Model to create. See list of available models below
**kwargs:
Key word arguments to be passed to the model
**Available ... |
def random(cls, mu=1.0, alphabet='nuc'):
"""
Creates a random GTR model
Parameters
----------
mu : float
Substitution rate
alphabet : str
Alphabet name (should be standard: 'nuc', 'nuc_gap', 'aa', 'aa_gap')
"""
alphabet=alph... |
def infer(cls, nij, Ti, root_state, fixed_pi=None, pc=5.0, gap_limit=0.01, **kwargs):
"""
Infer a GTR model by specifying the number of transitions and time spent in each
character. The basic equation that is being solved is
:math:`n_{ij} = pi_i W_{ij} T_j`
where :math:`n_{ij}`... |
def _check_fix_Q(self, fixed_mu=False):
"""
Check the main diagonal of Q and fix it in case it does not corresond
the definition of the rate matrix. Should be run every time when creating
custom GTR model.
"""
# fix Q
self.Pi /= self.Pi.sum() # correct the Pi manu... |
def _eig(self):
"""
Perform eigendecompositon of the rate matrix and stores the left- and right-
matrices to convert the sequence profiles to the GTR matrix eigenspace
and hence to speed-up the computations.
"""
# eigendecomposition of the rate matrix
eigvals, eig... |
def _eig_sym(self):
"""
Perform eigendecompositon of the rate matrix and stores the left- and right-
matrices to convert the sequence profiles to the GTR matrix eigenspace
and hence to speed-up the computations.
"""
# eigendecomposition of the rate matrix
tmpp = n... |
def compress_sequence_pair(self, seq_p, seq_ch, pattern_multiplicity=None,
ignore_gaps=False):
'''
Make a compressed representation of a pair of sequences, only counting
the number of times a particular pair of states (e.g. (A,T)) is observed
in the aligned... |
def prob_t_compressed(self, seq_pair, multiplicity, t, return_log=False):
'''
Calculate the probability of observing a sequence pair at a distance t,
for compressed sequences
Parameters
----------
seq_pair : numpy array
:code:`np.array([(0,1), (2,2), ()..]... |
def prob_t(self, seq_p, seq_ch, t, pattern_multiplicity = None,
return_log=False, ignore_gaps=True):
"""
Compute the probability to observe seq_ch (child sequence) after time t starting from seq_p
(parent sequence).
Parameters
----------
seq_p : characte... |
def optimal_t(self, seq_p, seq_ch, pattern_multiplicity=None, ignore_gaps=False):
'''
Find the optimal distance between the two sequences
Parameters
----------
seq_p : character array
Parent sequence
seq_c : character array
Child sequence
... |
def optimal_t_compressed(self, seq_pair, multiplicity, profiles=False, tol=1e-10):
"""
Find the optimal distance between the two sequences, for compressed sequences
Parameters
----------
seq_pair : compressed_sequence_pair
Compressed representation of sequences alo... |
def prob_t_profiles(self, profile_pair, multiplicity, t,
return_log=False, ignore_gaps=True):
'''
Calculate the probability of observing a node pair at a distance t
Parameters
----------
profile_pair: numpy arrays
Probability distributions ... |
def propagate_profile(self, profile, t, return_log=False):
"""
Compute the probability of the sequence state of the parent
at time (t+t0, backwards), given the sequence state of the
child (profile) at time t0.
Parameters
----------
profile : numpy.array
... |
def evolve(self, profile, t, return_log=False):
"""
Compute the probability of the sequence state of the child
at time t later, given the parent profile.
Parameters
----------
profile : numpy.array
Sequence profile. Shape = (L, a),
where L - seq... |
def _exp_lt(self, t):
"""
Parameters
----------
t : float
time to propagate
Returns
--------
exp_lt : numpy.array
Array of values exp(lambda(i) * t),
where (i) - alphabet index (the eigenvalue number).
"""
r... |
def expQt(self, t):
'''
Parameters
----------
t : float
Time to propagate
Returns
--------
expQt : numpy.array
Matrix exponential of exo(Qt)
'''
eLambdaT = np.diag(self._exp_lt(t)) # vector length = a
Qs = self.... |
def expQsds(self, s):
'''
Returns
-------
Qtds : Returns 2 V_{ij} \lambda_j s e^{\lambda_j s**2 } V^{-1}_{jk}
This is the derivative of the branch probability with respect to s=\sqrt(t)
'''
lambda_eLambdaT = np.diag(2.0*self._exp_lt(s**2)*self.eigenvals*s... |
def expQsdsds(self, s):
'''
Returns
-------
Qtdtdt : Returns V_{ij} \lambda_j^2 e^{\lambda_j s**2} V^{-1}_{jk}
This is the second derivative of the branch probability wrt time
'''
t=s**2
elt = self._exp_lt(t)
lambda_eLambdaT = np.diag(elt*... |
def sequence_logLH(self,seq, pattern_multiplicity=None):
"""
Returns the log-likelihood of sampling a sequence from equilibrium frequency.
Expects a sequence as numpy array
Parameters
----------
seq : numpy array
Compressed sequence as an array of chars
... |
def plot_vs_years(tt, step = None, ax=None, confidence=None, ticks=True, **kwargs):
'''
Converts branch length to years and plots the time tree on a time axis.
Parameters
----------
tt : TreeTime object
A TreeTime instance after a time tree is inferred
step : int
Width of sha... |
def run(self, root=None, infer_gtr=True, relaxed_clock=None, n_iqd = None,
resolve_polytomies=True, max_iter=0, Tc=None, fixed_clock_rate=None,
time_marginal=False, sequence_marginal=False, branch_length_mode='auto',
vary_rate=False, use_covariation=False, **kwargs):
"""
... |
def _set_branch_length_mode(self, branch_length_mode):
'''
if branch_length mode is not explicitly set, set according to
empirical branch length distribution in input tree
Parameters
----------
branch_length_mode : str, 'input', 'joint', 'marginal'
if the m... |
def clock_filter(self, reroot='least-squares', n_iqd=None, plot=False):
'''
Labels outlier branches that don't seem to follow a molecular clock
and excludes them from subsequent molecular clock estimation and
the timetree propagation.
Parameters
----------
reroo... |
def plot_root_to_tip(self, add_internal=False, label=True, ax=None):
"""
Plot root-to-tip regression
Parameters
----------
add_internal : bool
If true, plot inte`rnal node positions
label : bool
If true, label the plots
ax : matplotlib axe... |
def reroot(self, root='least-squares', force_positive=True, covariation=None):
"""
Find best root and re-root the tree to the new root
Parameters
----------
root : str
Which method should be used to find the best root. Available methods are:
:code:`bes... |
def resolve_polytomies(self, merge_compressed=False):
"""
Resolve the polytomies on the tree.
The function scans the tree, resolves polytomies if present,
and re-optimizes the tree with new topology. Note that polytomies are only
resolved if that would result in higher likelihoo... |
def _poly(self, clade, merge_compressed):
"""
Function to resolve polytomies for a given parent node. If the
number of the direct decendants is less than three (not a polytomy), does
nothing. Otherwise, for each pair of nodes, assess the possible LH increase
which could be gaine... |
def print_lh(self, joint=True):
"""
Print the total likelihood of the tree given the constrained leaves
Parameters
----------
joint : bool
If true, print joint LH, else print marginal LH
"""
try:
u_lh = self.tree.unconstrained_sequence_... |
def add_coalescent_model(self, Tc, **kwargs):
"""Add a coalescent model to the tree and optionally optimze
Parameters
----------
Tc : float,str
If this is a float, it will be interpreted as the inverse merger
rate in molecular clock units, if its is a
"""... |
def relaxed_clock(self, slack=None, coupling=None, **kwargs):
"""
Allow the mutation rate to vary on the tree (relaxed molecular clock).
Changes of the mutation rates from one branch to another are penalized.
In addition, deviation of the mutation rate from the mean rate is
penal... |
def _find_best_root(self, covariation=True, force_positive=True, slope=0, **kwarks):
'''
Determine the node that, when the tree is rooted on this node, results
in the best regression of temporal constraints and root to tip distances.
Parameters
----------
infer_gtr : b... |
def assure_tree(params, tmp_dir='treetime_tmp'):
"""
Function that attempts to load a tree and build it from the alignment
if no tree is provided.
"""
if params.tree is None:
params.tree = os.path.basename(params.aln)+'.nwk'
print("No tree given: inferring tree")
utils.tree_i... |
def create_gtr(params):
"""
parse the arguments referring to the GTR model and return a GTR structure
"""
model = params.gtr
gtr_params = params.gtr_params
if model == 'infer':
gtr = GTR.standard('jc', alphabet='aa' if params.aa else 'nuc')
else:
try:
kwargs = {}
... |
def read_if_vcf(params):
"""
Checks if input is VCF and reads in appropriately if it is
"""
ref = None
aln = params.aln
fixed_pi = None
if hasattr(params, 'aln') and params.aln is not None:
if any([params.aln.lower().endswith(x) for x in ['.vcf', '.vcf.gz']]):
if not para... |
def scan_homoplasies(params):
"""
the function implementing treetime homoplasies
"""
if assure_tree(params, tmp_dir='homoplasy_tmp'):
return 1
gtr = create_gtr(params)
###########################################################################
### READ IN VCF
##################... |
def timetree(params):
"""
implementeing treetime tree
"""
if params.relax is None:
relaxed_clock_params = None
elif params.relax==[]:
relaxed_clock_params=True
elif len(params.relax)==2:
relaxed_clock_params={'slack':params.relax[0], 'coupling':params.relax[1]}
date... |
def ancestral_reconstruction(params):
"""
implementing treetime ancestral
"""
# set up
if assure_tree(params, tmp_dir='ancestral_tmp'):
return 1
outdir = get_outdir(params, '_ancestral')
basename = get_basename(params, outdir)
gtr = create_gtr(params)
####################... |
def mugration(params):
"""
implementing treetime mugration
"""
###########################################################################
### Parse states
###########################################################################
if os.path.isfile(params.states):
states = pd.read_... |
def estimate_clock_model(params):
"""
implementing treetime clock
"""
if assure_tree(params, tmp_dir='clock_model_tmp'):
return 1
dates = utils.parse_dates(params.dates)
if len(dates)==0:
return 1
outdir = get_outdir(params, '_clock')
##################################... |
def calc_fwhm(distribution, is_neg_log=True):
"""
Assess the width of the probability distribution. This returns
full-width-half-max
"""
if isinstance(distribution, interp1d):
if is_neg_log:
ymin = distribution.y.min()
log_prob = dist... |
def delta_function(cls, x_pos, weight=1., min_width=MIN_INTEGRATION_PEAK):
"""
Create delta function distribution.
"""
distribution = cls(x_pos,0.,is_log=True, min_width=min_width)
distribution.weight = weight
return distribution |
def multiply(dists):
'''
multiplies a list of Distribution objects
'''
if not all([isinstance(k, Distribution) for k in dists]):
raise NotImplementedError("Can only multiply Distribution objects")
n_delta = np.sum([k.is_delta for k in dists])
min_width = np.... |
def _assign_dates(self):
"""assign dates to nodes
Returns
-------
str
success/error code
"""
if self.tree is None:
self.logger("ClockTree._assign_dates: tree is not set, can't assign dates", 0)
return ttconf.ERROR
bad_branch_c... |
def _set_precision(self, precision):
'''
function that sets precision to an (hopfully) reasonable guess based
on the length of the sequence if not explicitly set
'''
# if precision is explicitly specified, use it.
if self.one_mutation:
self.min_width = 10*sel... |
def setup_TreeRegression(self, covariation=True):
"""instantiate a TreeRegression object and set its tip_value and branch_value function
to defaults that are sensible for treetime instances.
Parameters
----------
covariation : bool, optional
account for phylogenetic ... |
def init_date_constraints(self, ancestral_inference=False, clock_rate=None, **kwarks):
"""
Get the conversion coefficients between the dates and the branch
lengths as they are used in ML computations. The conversion formula is
assumed to be 'length = k*numdate + b'. For convenience, thes... |
def make_time_tree(self, time_marginal=False, clock_rate=None, **kwargs):
'''
Use the date constraints to calculate the most likely positions of
unconstrained nodes.
Parameters
----------
time_marginal : bool
If true, use marginal reconstruction for node po... |
def _ml_t_joint(self):
"""
Compute the joint maximum likelihood assignment of the internal nodes positions by
propagating from the tree leaves towards the root. Given the assignment of parent nodes,
reconstruct the maximum-likelihood positions of the child nodes by propagating
fr... |
def timetree_likelihood(self):
'''
Return the likelihood of the data given the current branch length in the tree
'''
LH = 0
for node in self.tree.find_clades(order='preorder'): # sum the likelihood contributions of all branches
if node.up is None: # root node
... |
def _ml_t_marginal(self, assign_dates=False):
"""
Compute the marginal probability distribution of the internal nodes positions by
propagating from the tree leaves towards the root. The result of
this operation are the probability distributions of each internal node,
conditional ... |
def convert_dates(self):
'''
This function converts the estimated "time_before_present" properties of all nodes
to numerical dates stored in the "numdate" attribute. This date is further converted
into a human readable date string in format %Y-%m-%d assuming the usual calendar.
... |
def branch_length_to_years(self):
'''
This function sets branch length to reflect the date differences between parent and child
nodes measured in years. Should only be called after :py:meth:`timetree.ClockTree.convert_dates` has been called.
Returns
-------
None
... |
def calc_rate_susceptibility(self, rate_std=None, params=None):
"""return the time tree estimation of evolutionary rates +/- one
standard deviation form the ML estimate.
Returns
-------
TreeTime.return_code : str
success or failure
"""
params = params... |
def date_uncertainty_due_to_rate(self, node, interval=(0.05, 0.095)):
"""use previously calculated variation of the rate to estimate
the uncertainty in a particular numdate due to rate variation.
Parameters
----------
node : PhyloTree.Clade
node for which the confide... |
def get_confidence_interval(self, node, interval = (0.05, 0.95)):
'''
If temporal reconstruction was done using the marginal ML mode, the entire distribution of
times is available. This function determines the 90% (or other) confidence interval, defined as the
range where 5% of probabili... |
def get_max_posterior_region(self, node, fraction = 0.9):
'''
If temporal reconstruction was done using the marginal ML mode, the entire distribution of
times is available. This function determines the interval around the highest
posterior probability region that contains the specified f... |
def read_vcf(vcf_file, ref_file):
"""
Reads in a vcf/vcf.gz file and associated
reference sequence fasta (to which the VCF file is mapped).
Parses mutations, insertions, and deletions and stores them in a nested dict,
see 'returns' for the dict structure.
Calls with heterozygous values... |
def write_vcf(tree_dict, file_name):#, compress=False):
"""
Writes out a VCF-style file (which seems to be minimally handleable
by vcftools and pyvcf) of the alignment. This is created from a dict
in a similar format to what's created by :py:meth:`treetime.vcf_utils.read_vcf`
Positions of var... |
def _convolution_integrand(t_val, f, g,
inverse_time=None, return_log=False):
'''
Evaluates int_tau f(t+tau)*g(tau) or int_tau f(t-tau)g(tau) if inverse time is TRUE
Parameters
-----------
t_val : double
Time point
f : Interpolation object
First mu... |
def _max_of_integrand(t_val, f, g, inverse_time=None, return_log=False):
'''
Evaluates max_tau f(t+tau)*g(tau) or max_tau f(t-tau)g(tau) if inverse time is TRUE
Parameters
-----------
t_val : double
Time point
f : Interpolation object
First multiplier in convolution
g... |
def _evaluate_convolution(t_val, f, g, n_integral = 100, inverse_time=None, return_log=False):
"""
Calculate convolution F(t) = int { f(tau)g(t-tau) } dtau
"""
FG = _convolution_integrand(t_val, f, g, inverse_time, return_log)
#integrate the interpolation object, return log, make neg_log
... |
def convolve(cls, node_interp, branch_interp, max_or_integral='integral',
n_grid_points = ttconf.NODE_GRID_SIZE, n_integral=ttconf.N_INTEGRAL,
inverse_time=True, rel_tol=0.05, yc=10):
'''
calculate H(t) = \int_tau f(t-tau)g(tau) if inverse_time=True
H... |
def min_interp(interp_object):
"""
Find the global minimum of a function represented as an interpolation object.
"""
try:
return interp_object.x[interp_object(interp_object.x).argmin()]
except Exception as e:
s = "Cannot find minimum of the interpolation object" + str(interp_object.x... |
def median_interp(interp_object):
"""
Find the median of the function represented as an interpolation object.
"""
new_grid = np.sort(np.concatenate([interp_object.x[:-1] + 0.1*ii*np.diff(interp_object.x)
for ii in range(10)]).flatten())
tmp_prop = np.exp(-(int... |
def numeric_date(dt=None):
"""
Convert datetime object to the numeric date.
The numeric date format is YYYY.F, where F is the fraction of the year passed
Parameters
----------
dt: datetime.datetime, None
date of to be converted. if None, assume today
"""
if dt is None:
... |
def parse_dates(date_file):
"""
parse dates from the arguments and return a dictionary mapping
taxon names to numerical dates.
Parameters
----------
date_file : str
name of file to parse meta data from
Returns
-------
dict
dictionary linking fields in a column inter... |
def ambiguous_date_to_date_range(mydate, fmt="%Y-%m-%d", min_max_year=None):
"""parse an abiguous date such as 2017-XX-XX to [2017,2017.999]
Parameters
----------
mydate : str
date string to be parsed
fmt : str
format descriptor. default is %Y-%m-%d
min_max_year : None, optional... |
def from_regression(cls, clock_model):
"""
Create the conversion object automatically from the tree
Parameters
----------
clock_model : dict
dictionary as returned from TreeRegression with fields intercept and slope
"""
dc = cls()
dc.clock_... |
def client(self):
"""
Socket connection.
"""
if not self._client:
self._client = socket.create_connection(
(self.host, self.port), self.timeout)
self.logger.debug('Client connected with guacd server (%s, %s, %s)'
% (se... |
def close(self):
"""
Terminate connection with Guacamole guacd server.
"""
self.client.close()
self._client = None
self.connected = False
self.logger.debug('Connection closed.') |
def receive(self):
"""
Receive instructions from Guacamole guacd server.
"""
start = 0
while True:
idx = self._buffer.find(INST_TERM.encode(), start)
if idx != -1:
# instruction was fully received!
line = self._buffer[:idx ... |
def send(self, data):
"""
Send encoded instructions to Guacamole guacd server.
"""
self.logger.debug('Sending data: %s' % data)
self.client.sendall(data.encode()) |
def send_instruction(self, instruction):
"""
Send instruction after encoding.
"""
self.logger.debug('Sending instruction: %s' % str(instruction))
return self.send(instruction.encode()) |
def handshake(self, protocol='vnc', width=1024, height=768, dpi=96,
audio=None, video=None, image=None, **kwargs):
"""
Establish connection with Guacamole guacd server via handshake.
"""
if protocol not in PROTOCOLS:
self.logger.debug('Invalid protocol: %s' ... |
def utf8(unicode_str):
"""
Return a utf-8 encoded string from a valid unicode string.
:param unicode_str: Unicode string.
:return: str
"""
if six.PY2 and isinstance(unicode_str, __unicode__):
return unicode_str.encode('utf-8')
return unicode_str |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.