INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Create DataFrames of nodes and edges that do not include specified nodes. | def remove_nodes(network, rm_nodes):
"""
Create DataFrames of nodes and edges that do not include specified nodes.
Parameters
----------
network : pandana.Network
rm_nodes : array_like
A list, array, Index, or Series of node IDs that should *not*
be saved as part of the Network.... |
Save a Network s data to a Pandas HDFStore. | def network_to_pandas_hdf5(network, filename, rm_nodes=None):
"""
Save a Network's data to a Pandas HDFStore.
Parameters
----------
network : pandana.Network
filename : str
rm_nodes : array_like
A list, array, Index, or Series of node IDs that should *not*
be saved as part o... |
Build a Network from data in a Pandas HDFStore. | def network_from_pandas_hdf5(cls, filename):
"""
Build a Network from data in a Pandas HDFStore.
Parameters
----------
cls : class
Class to instantiate, usually pandana.Network.
filename : str
Returns
-------
network : pandana.Network
"""
with pd.HDFStore(filename)... |
The bounding box for nodes in this network [ xmin ymin xmax ymax ] | def bbox(self):
"""
The bounding box for nodes in this network [xmin, ymin, xmax, ymax]
"""
return [self.nodes_df.x.min(), self.nodes_df.y.min(),
self.nodes_df.x.max(), self.nodes_df.y.max()] |
Characterize urban space with a variable that is related to nodes in the network. | def set(self, node_ids, variable=None, name="tmp"):
"""
Characterize urban space with a variable that is related to nodes in
the network.
Parameters
----------
node_ids : Pandas Series, int
A series of node_ids which are usually computed using
get... |
Aggregate information for every source node in the network - this is really the main purpose of this library. This allows you to touch the data specified by calling set and perform some aggregation on it within the specified distance. For instance summing the population within 1000 meters. | def aggregate(self, distance, type="sum", decay="linear", imp_name=None,
name="tmp"):
"""
Aggregate information for every source node in the network - this is
really the main purpose of this library. This allows you to touch
the data specified by calling set and perfor... |
Assign node_ids to data specified by x_col and y_col | def get_node_ids(self, x_col, y_col, mapping_distance=None):
"""
Assign node_ids to data specified by x_col and y_col
Parameters
----------
x_col : Pandas series (float)
A Pandas Series where values specify the x (e.g. longitude)
location of dataset.
... |
Plot an array of data on a map using matplotlib and Basemap automatically matching the data to the Pandana network node positions. | def plot(
self, data, bbox=None, plot_type='scatter',
fig_kwargs=None, bmap_kwargs=None, plot_kwargs=None,
cbar_kwargs=None):
"""
Plot an array of data on a map using matplotlib and Basemap,
automatically matching the data to the Pandana network node positions... |
Set the location of all the pois of this category. The pois are connected to the closest node in the Pandana network which assumes no impedance between the location of the variable and the location of the closest network node. | def set_pois(self, category, maxdist, maxitems, x_col, y_col):
"""
Set the location of all the pois of this category. The pois are
connected to the closest node in the Pandana network which assumes
no impedance between the location of the variable and the location
of the closest ... |
Find the distance to the nearest pois from each source node. The bigger values in this case mean less accessibility. | def nearest_pois(self, distance, category, num_pois=1, max_distance=None,
imp_name=None, include_poi_ids=False):
"""
Find the distance to the nearest pois from each source node. The
bigger values in this case mean less accessibility.
Parameters
----------
... |
Identify nodes that are connected to fewer than some threshold of other nodes within a given distance. | def low_connectivity_nodes(self, impedance, count, imp_name=None):
"""
Identify nodes that are connected to fewer than some threshold
of other nodes within a given distance.
Parameters
----------
impedance : float
Distance within which to search for other con... |
Make a Pandana network from a bounding lat/ lon box request to the Overpass API. Distance will be in the default units meters. | def pdna_network_from_bbox(
lat_min=None, lng_min=None, lat_max=None, lng_max=None, bbox=None,
network_type='walk', two_way=True,
timeout=180, memory=None, max_query_area_size=50 * 1000 * 50 * 1000):
"""
Make a Pandana network from a bounding lat/lon box
request to the Overpass API. ... |
Process a node element entry into a dict suitable for going into a Pandas DataFrame. | def process_node(e):
"""
Process a node element entry into a dict suitable for going into
a Pandas DataFrame.
Parameters
----------
e : dict
Returns
-------
node : dict
"""
uninteresting_tags = {
'source',
'source_ref',
'source:ref',
'history... |
Make a request to OSM and return the parsed JSON. | def make_osm_query(query):
"""
Make a request to OSM and return the parsed JSON.
Parameters
----------
query : str
A string in the Overpass QL format.
Returns
-------
data : dict
"""
osm_url = 'http://www.overpass-api.de/api/interpreter'
req = requests.get(osm_url,... |
Build the string for a node - based OSM query. | def build_node_query(lat_min, lng_min, lat_max, lng_max, tags=None):
"""
Build the string for a node-based OSM query.
Parameters
----------
lat_min, lng_min, lat_max, lng_max : float
tags : str or list of str, optional
Node tags that will be used to filter the search.
See http:/... |
Search for OSM nodes within a bounding box that match given tags. | def node_query(lat_min, lng_min, lat_max, lng_max, tags=None):
"""
Search for OSM nodes within a bounding box that match given tags.
Parameters
----------
lat_min, lng_min, lat_max, lng_max : float
tags : str or list of str, optional
Node tags that will be used to filter the search.
... |
Shortcut function for unittest. TestCase. assertEqual (). | def equal(x, y):
"""
Shortcut function for ``unittest.TestCase.assertEqual()``.
Arguments:
x (mixed)
y (mixed)
Raises:
AssertionError: in case of assertion error.
Returns:
bool
"""
if PY_3:
return test_case().assertEqual(x, y) or True
assert x ... |
Tries to match a regular expression value x against y. Aliast unittest. TestCase. assertEqual () | def matches(x, y, regex_expr=False):
"""
Tries to match a regular expression value ``x`` against ``y``.
Aliast``unittest.TestCase.assertEqual()``
Arguments:
x (regex|str): regular expression to test.
y (str): value to match.
regex_expr (bool): enables regex string based expressi... |
Returns True is the given expression value is a regular expression like string with prefix re/ and suffix/ otherwise False. | def isregex_expr(expr):
"""
Returns ``True`` is the given expression value is a regular expression
like string with prefix ``re/`` and suffix ``/``, otherwise ``False``.
Arguments:
expr (mixed): expression value to test.
Returns:
bool
"""
if not isinstance(expr, str):
... |
Returns True if the input argument object is a native regular expression object otherwise False. | def isregex(value):
"""
Returns ``True`` if the input argument object is a native
regular expression object, otherwise ``False``.
Arguments:
value (mixed): input value to test.
Returns:
bool
"""
if not value:
return False
return any((isregex_expr(value), isinsta... |
Compares two values with regular expression matching support. | def compare(self, value, expectation, regex_expr=False):
"""
Compares two values with regular expression matching support.
Arguments:
value (mixed): value to compare.
expectation (mixed): value to match.
regex_expr (bool, optional): enables string based regex... |
Simple function decorator allowing easy method chaining. | def fluent(fn):
"""
Simple function decorator allowing easy method chaining.
Arguments:
fn (function): target function to decorate.
"""
@functools.wraps(fn)
def wrapper(self, *args, **kw):
# Trigger method proxy
result = fn(self, *args, **kw)
# Return self instan... |
Compares an string or regular expression againast a given value. | def compare(expr, value, regex_expr=False):
"""
Compares an string or regular expression againast a given value.
Arguments:
expr (str|regex): string or regular expression value to compare.
value (str): value to compare against to.
regex_expr (bool, optional): enables string based re... |
Triggers specific class methods using a simple reflection mechanism based on the given input dictionary params. | def trigger_methods(instance, args):
""""
Triggers specific class methods using a simple reflection
mechanism based on the given input dictionary params.
Arguments:
instance (object): target instance to dynamically trigger methods.
args (iterable): input arguments to trigger objects to
... |
Match the given HTTP request instance against the registered matcher functions in the current engine. | def match(self, request):
"""
Match the given HTTP request instance against the registered
matcher functions in the current engine.
Arguments:
request (pook.Request): outgoing request to match.
Returns:
tuple(bool, list[Exception]): ``True`` if all match... |
Returns a matcher instance by class or alias name. | def get(name):
"""
Returns a matcher instance by class or alias name.
Arguments:
name (str): matcher class name or alias.
Returns:
matcher: found matcher instance, otherwise ``None``.
"""
for matcher in matchers:
if matcher.__name__ == name or getattr(matcher, 'name', N... |
Initializes a matcher instance passing variadic arguments to its constructor. Acts as a delegator proxy. | def init(name, *args):
"""
Initializes a matcher instance passing variadic arguments to
its constructor. Acts as a delegator proxy.
Arguments:
name (str): matcher class name or alias to execute.
*args (mixed): variadic argument
Returns:
matcher: matcher instance.
Raise... |
Defines a new response header. Alias to Response. header (). | def header(self, key, value):
"""
Defines a new response header.
Alias to ``Response.header()``.
Arguments:
header (str): header name.
value (str): header value.
Returns:
self: ``pook.Response`` current instance.
"""
if type(k... |
Defines response body data. | def body(self, body):
"""
Defines response body data.
Arguments:
body (str|bytes): response body to use.
Returns:
self: ``pook.Response`` current instance.
"""
if isinstance(body, bytes):
body = body.decode('utf-8')
self._bod... |
Defines the mock response JSON body. | def json(self, data):
"""
Defines the mock response JSON body.
Arguments:
data (dict|list|str): JSON body data.
Returns:
self: ``pook.Response`` current instance.
"""
self._headers['Content-Type'] = 'application/json'
if not isinstance(da... |
Sets a header field with the given value removing previous values. | def set(self, key, val):
"""
Sets a header field with the given value, removing
previous values.
Usage::
headers = HTTPHeaderDict(foo='bar')
headers.set('Foo', 'baz')
headers['foo']
> 'baz'
"""
key_lower = key.lower()
... |
Helper function to append functions into a given list. | def _append_funcs(target, items):
"""
Helper function to append functions into a given list.
Arguments:
target (list): receptor list to append functions.
items (iterable): iterable that yields elements to append.
"""
[target.append(item) for item in items
if isfunction(item) or... |
Triggers request mock definition methods dynamically based on input keyword arguments passed to pook. Mock constructor. | def _trigger_request(instance, request):
"""
Triggers request mock definition methods dynamically based on input
keyword arguments passed to `pook.Mock` constructor.
This is used to provide a more Pythonic interface vs chainable API
approach.
"""
if not isinstance(request, Request):
... |
Defines the mock URL to match. It can be a full URL with path and query params. | def url(self, url):
"""
Defines the mock URL to match.
It can be a full URL with path and query params.
Protocol schema is optional, defaults to ``http://``.
Arguments:
url (str): mock URL to match. E.g: ``server.com/api``.
Returns:
self: curren... |
Defines the HTTP method to match. Use * to match any method. | def method(self, method):
"""
Defines the HTTP method to match.
Use ``*`` to match any method.
Arguments:
method (str): method value to match. E.g: ``GET``.
Returns:
self: current Mock instance.
"""
self._request.method = method
s... |
Defines a URL path to match. | def path(self, path):
"""
Defines a URL path to match.
Only call this method if the URL has no path already defined.
Arguments:
path (str): URL path value to match. E.g: ``/api/users``.
Returns:
self: current Mock instance.
"""
url = fur... |
Defines a URL path to match. | def header(self, name, value):
"""
Defines a URL path to match.
Only call this method if the URL has no path already defined.
Arguments:
path (str): URL path value to match. E.g: ``/api/users``.
Returns:
self: current Mock instance.
"""
... |
Defines a dictionary of arguments. | def headers(self, headers=None, **kw):
"""
Defines a dictionary of arguments.
Header keys are case insensitive.
Arguments:
headers (dict): headers to match.
**headers (dict): headers to match as variadic keyword arguments.
Returns:
self: cur... |
Defines a new header matcher expectation that must be present in the outgoing request in order to be satisfied no matter what value it hosts. | def header_present(self, *names):
"""
Defines a new header matcher expectation that must be present in the
outgoing request in order to be satisfied, no matter what value it
hosts.
Header keys are case insensitive.
Arguments:
*names (str): header or headers ... |
Defines a list of headers that must be present in the outgoing request in order to satisfy the matcher no matter what value the headers hosts. | def headers_present(self, headers):
"""
Defines a list of headers that must be present in the
outgoing request in order to satisfy the matcher, no matter what value
the headers hosts.
Header keys are case insensitive.
Arguments:
headers (list|tuple): header ... |
Defines the Content - Type outgoing header value to match. | def content(self, value):
"""
Defines the ``Content-Type`` outgoing header value to match.
You can pass one of the following type aliases instead of the full
MIME type representation:
- ``json`` = ``application/json``
- ``xml`` = ``application/xml``
- ``html`` =... |
Defines a set of URL query params to match. | def params(self, params):
"""
Defines a set of URL query params to match.
Arguments:
params (dict): set of params to match.
Returns:
self: current Mock instance.
"""
url = furl(self._request.rawurl)
url = url.add(params)
self._req... |
Defines the body data to match. | def body(self, body):
"""
Defines the body data to match.
``body`` argument can be a ``str``, ``binary`` or a regular expression.
Arguments:
body (str|binary|regex): body data to match.
Returns:
self: current Mock instance.
"""
self._req... |
Defines the JSON body to match. | def json(self, json):
"""
Defines the JSON body to match.
``json`` argument can be an JSON string, a JSON serializable
Python structure, such as a ``dict`` or ``list`` or it can be
a regular expression used to match the body.
Arguments:
json (str|dict|list|r... |
Defines a XML body value to match. | def xml(self, xml):
"""
Defines a XML body value to match.
Arguments:
xml (str|regex): body XML to match.
Returns:
self: current Mock instance.
"""
self._request.xml = xml
self.add_matcher(matcher('XMLMatcher', xml)) |
Reads the body to match from a disk file. | def file(self, path):
"""
Reads the body to match from a disk file.
Arguments:
path (str): relative or absolute path to file to read from.
Returns:
self: current Mock instance.
"""
with open(path, 'r') as f:
self.body(str(f.read())) |
Enables persistent mode for the current mock. | def persist(self, status=None):
"""
Enables persistent mode for the current mock.
Returns:
self: current Mock instance.
"""
self._persist = status if type(status) is bool else True |
Defines a simulated exception error that will be raised. | def error(self, error):
"""
Defines a simulated exception error that will be raised.
Arguments:
error (str|Exception): error to raise.
Returns:
self: current Mock instance.
"""
self._error = RuntimeError(error) if isinstance(error, str) else erro... |
Defines the mock response. | def reply(self, status=200, new_response=False, **kw):
"""
Defines the mock response.
Arguments:
status (int, optional): response status code. Defaults to ``200``.
**kw (dict): optional keyword arguments passed to ``pook.Response``
constructor.
R... |
Matches an outgoing HTTP request against the current mock matchers. | def match(self, request):
"""
Matches an outgoing HTTP request against the current mock matchers.
This method acts like a delegator to `pook.MatcherEngine`.
Arguments:
request (pook.Request): request instance to match.
Raises:
Exception: if the mock has... |
Async version of activate decorator | def activate_async(fn, _engine):
"""
Async version of activate decorator
Arguments:
fn (function): function that be wrapped by decorator.
_engine (Engine): pook engine instance
Returns:
function: decorator wrapper function.
"""
@coroutine
@functools.wraps(fn)
de... |
Sets a custom mock engine replacing the built - in one. | def set_mock_engine(self, engine):
"""
Sets a custom mock engine, replacing the built-in one.
This is particularly useful if you want to replace the built-in
HTTP traffic mock interceptor engine with your custom one.
For mock engine implementation details, see `pook.MockEngine`... |
Enables real networking mode optionally passing one or multiple hostnames that would be used as filter. | def enable_network(self, *hostnames):
"""
Enables real networking mode, optionally passing one or multiple
hostnames that would be used as filter.
If at least one hostname matches with the outgoing traffic, the
request will be executed via the real network.
Arguments:
... |
Creates and registers a new HTTP mock in the current engine. | def mock(self, url=None, **kw):
"""
Creates and registers a new HTTP mock in the current engine.
Arguments:
url (str): request URL to mock.
activate (bool): force mock engine activation.
Defaults to ``False``.
**kw (mixed): variadic keyword ar... |
Removes a specific mock instance by object reference. | def remove_mock(self, mock):
"""
Removes a specific mock instance by object reference.
Arguments:
mock (pook.Mock): mock instance to remove.
"""
self.mocks = [m for m in self.mocks if m is not mock] |
Activates the registered interceptors in the mocking engine. | def activate(self):
"""
Activates the registered interceptors in the mocking engine.
This means any HTTP traffic captures by those interceptors will
trigger the HTTP mock matching engine in order to determine if a given
HTTP transaction should be mocked out or not.
"""
... |
Disables interceptors and stops intercepting any outgoing HTTP traffic. | def disable(self):
"""
Disables interceptors and stops intercepting any outgoing HTTP traffic.
"""
if not self.active:
return None
# Disable current mock engine
self.mock_engine.disable()
# Disable engine state
self.active = False |
Verifies if real networking mode should be used for the given request passing it to the registered network filters. | def should_use_network(self, request):
"""
Verifies if real networking mode should be used for the given
request, passing it to the registered network filters.
Arguments:
request (pook.Request): outgoing HTTP request to test.
Returns:
bool
"""
... |
Matches a given Request instance contract against the registered mocks. | def match(self, request):
"""
Matches a given Request instance contract against the registered mocks.
If a mock passes all the matchers, its response will be returned.
Arguments:
request (pook.Request): Request contract to match.
Raises:
pook.PookNoMatc... |
Copies the current Request object instance for side - effects purposes. | def copy(self):
"""
Copies the current Request object instance for side-effects purposes.
Returns:
pook.Request: copy of the current Request instance.
"""
req = type(self)()
req.__dict__ = self.__dict__.copy()
req._headers = self.headers.copy()
... |
Enables the HTTP traffic interceptors. | def activate(fn=None):
"""
Enables the HTTP traffic interceptors.
This function can be used as decorator.
Arguments:
fn (function|coroutinefunction): Optional function argument
if used as decorator.
Returns:
function: decorator wrapper function, only if called as decor... |
Creates a new isolated mock engine to be used via context manager. | def use(network=False):
"""
Creates a new isolated mock engine to be used via context manager.
Example::
with pook.use() as engine:
pook.mock('server.com/foo').reply(404)
res = requests.get('server.com/foo')
assert res.status_code == 404
"""
global _eng... |
Convenient shortcut to re. compile () for fast easy to use regular expression compilation without an extra import statement. | def regex(expression, flags=re.IGNORECASE):
"""
Convenient shortcut to ``re.compile()`` for fast, easy to use
regular expression compilation without an extra import statement.
Arguments:
expression (str): regular expression value.
flags (int): optional regular expression flags.
... |
Adds one or multiple HTTP traffic interceptors to the current mocking engine. | def add_interceptor(self, *interceptors):
"""
Adds one or multiple HTTP traffic interceptors to the current
mocking engine.
Interceptors are typically HTTP client specific wrapper classes that
implements the pook interceptor interface.
Arguments:
interceptor... |
Removes a specific interceptor by name. | def remove_interceptor(self, name):
"""
Removes a specific interceptor by name.
Arguments:
name (str): interceptor name to disable.
Returns:
bool: `True` if the interceptor was disabled, otherwise `False`.
"""
for index, interceptor in enumerate(... |
Get key from connection or default to settings. | def get_setting(connection, key):
"""Get key from connection or default to settings."""
if key in connection.settings_dict:
return connection.settings_dict[key]
else:
return getattr(settings, key) |
Build SQL with decryption and casting. | def as_sql(self, compiler, connection):
"""Build SQL with decryption and casting."""
sql, params = super(DecryptedCol, self).as_sql(compiler, connection)
sql = self.target.get_decrypt_sql(connection) % (sql, self.target.get_cast_sql())
return sql, params |
Save the original_value. | def pre_save(self, model_instance, add):
"""Save the original_value."""
if self.original:
original_value = getattr(model_instance, self.original)
setattr(model_instance, self.attname, original_value)
return super(HashMixin, self).pre_save(model_instance, add) |
Tell postgres to encrypt this field with a hashing function. | def get_placeholder(self, value=None, compiler=None, connection=None):
"""
Tell postgres to encrypt this field with a hashing function.
The `value` string is checked to determine if we need to hash or keep
the current value.
`compiler` and `connection` is ignored here as we don... |
Get the decryption for col. | def get_col(self, alias, output_field=None):
"""Get the decryption for col."""
if output_field is None:
output_field = self
if alias != self.model._meta.db_table or output_field != self:
return DecryptedCol(
alias,
self,
out... |
Tell postgres to encrypt this field using PGP. | def get_placeholder(self, value=None, compiler=None, connection=None):
"""Tell postgres to encrypt this field using PGP."""
return self.encrypt_sql.format(get_setting(connection, 'PUBLIC_PGP_KEY')) |
Parses yaml and returns a list of repeated variables and the line on which they occur | def hunt_repeated_yaml_keys(data):
"""Parses yaml and returns a list of repeated variables and
the line on which they occur
"""
loader = yaml.Loader(data)
def compose_node(parent, index):
# the line number where the previous token has ended (plus empty lines)
line = loader.line
... |
this function calculates the regression coefficients for a given vector containing the averages of tip and branch quantities. | def base_regression(Q, slope=None):
"""
this function calculates the regression coefficients for a
given vector containing the averages of tip and branch
quantities.
Parameters
----------
Q : numpy.array
vector with
slope : None, optional
Description
Returns
---... |
calculate the covariance matrix of the tips assuming variance has accumulated along branches of the tree accoriding to the the provided Returns ------- | def Cov(self):
"""
calculate the covariance matrix of the tips assuming variance
has accumulated along branches of the tree accoriding to the
the provided
Returns
-------
M : (np.array)
covariance matrix with tips arranged standard transersal order.
... |
Inverse of the covariance matrix | def CovInv(self):
"""
Inverse of the covariance matrix
Returns
-------
H : (np.array)
inverse of the covariance matrix.
"""
self.recurse(full_matrix=True)
return self.tree.root.cinv |
recursion to calculate inverse covariance matrix | def recurse(self, full_matrix=False):
"""
recursion to calculate inverse covariance matrix
Parameters
----------
full_matrix : bool, optional
if True, the entire inverse matrix is calculated. otherwise, only the weighing vector.
"""
for n in self.tree... |
calculate the weighted sums of the tip and branch values and their second moments. | def _calculate_averages(self):
"""
calculate the weighted sums of the tip and branch values and
their second moments.
"""
for n in self.tree.get_nonterminals(order='postorder'):
Q = np.zeros(6, dtype=float)
for c in n:
tv = self.tip_value(c... |
This function implements the propagation of the means variance and covariances along a branch. It operates both towards the root and tips. | def propagate_averages(self, n, tv, bv, var, outgroup=False):
"""
This function implements the propagation of the means,
variance, and covariances along a branch. It operates
both towards the root and tips.
Parameters
----------
n : (node)
the branch... |
calculate standard explained variance | def explained_variance(self):
"""calculate standard explained variance
Returns
-------
float
r-value of the root-to-tip distance and time.
independent of regression model, but dependent on root choice
"""
self.tree.root._v=0
for n in self.... |
regress tip values against branch values | def regression(self, slope=None):
"""regress tip values against branch values
Parameters
----------
slope : None, optional
if given, the slope isn't optimized
Returns
-------
dict
regression parameters
"""
self._calculate_... |
determine the position on the tree that minimizes the bilinear product of the inverse covariance and the data vectors. | def find_best_root(self, force_positive=True, slope=None):
"""
determine the position on the tree that minimizes the bilinear
product of the inverse covariance and the data vectors.
Returns
-------
best_root : (dict)
dictionary with the node, the fraction `x... |
determine the best root and reroot the tree to this value. Note that this can change the parent child relations of the tree and values associated with branches rather than nodes ( e. g. confidence ) might need to be re - evaluated afterwards | def optimal_reroot(self, force_positive=True, slope=None):
"""
determine the best root and reroot the tree to this value.
Note that this can change the parent child relations of the tree
and values associated with branches rather than nodes
(e.g. confidence) might need to be re-e... |
Plot root - to - tip distance vs time as a basic time - tree diagnostic | def clock_plot(self, add_internal=False, ax=None, regression=None,
confidence=True, n_sigma = 2, fs=14):
"""Plot root-to-tip distance vs time as a basic time-tree diagnostic
Parameters
----------
add_internal : bool, optional
add internal nodes. this will ... |
Jukes - Cantor 1969 model. This model assumes equal concentrations of the nucleotides and equal transition rates between nucleotide states. For more info see: Jukes and Cantor ( 1969 ). Evolution of Protein Molecules. New York: Academic Press. pp. 21–132 | def JC69 (mu=1.0, alphabet="nuc", **kwargs):
"""
Jukes-Cantor 1969 model. This model assumes equal concentrations
of the nucleotides and equal transition rates between nucleotide states.
For more info, see: Jukes and Cantor (1969). Evolution of Protein Molecules.
New York: Academ... |
Kimura 1980 model. Assumes equal concentrations across nucleotides but allows different rates between transitions and transversions. The ratio of the transversion/ transition rates is given by kappa parameter. For more info see Kimura ( 1980 ) J. Mol. Evol. 16 ( 2 ): 111–120. doi: 10. 1007/ BF01731581. | def K80(mu=1., kappa=0.1, **kwargs):
"""
Kimura 1980 model. Assumes equal concentrations across nucleotides, but
allows different rates between transitions and transversions. The ratio
of the transversion/transition rates is given by kappa parameter.
For more info, see
Kimura (1980), J. Mol. Ev... |
Felsenstein 1981 model. Assumes non - equal concentrations across nucleotides but the transition rate between all states is assumed to be equal. See Felsenstein ( 1981 ) J. Mol. Evol. 17 ( 6 ): 368–376. doi: 10. 1007/ BF01734359 for details. | def F81(mu=1.0, pi=None, alphabet="nuc", **kwargs):
"""
Felsenstein 1981 model. Assumes non-equal concentrations across nucleotides,
but the transition rate between all states is assumed to be equal. See
Felsenstein (1981), J. Mol. Evol. 17 (6): 368–376. doi:10.1007/BF01734359
for details.
Cur... |
Hasegawa Kishino and Yano 1985 model. Allows different concentrations of the nucleotides ( as in F81 ) + distinguishes between transition/ transversionsubstitutions ( similar to K80 ). Link: Hasegawa Kishino Yano ( 1985 ) J. Mol. Evol. 22 ( 2 ): 160–174. doi: 10. 1007/ BF02101694 | def HKY85(mu=1.0, pi=None, kappa=0.1, **kwargs):
"""
Hasegawa, Kishino and Yano 1985 model. Allows different concentrations of the
nucleotides (as in F81) + distinguishes between transition/transversionsubstitutions
(similar to K80). Link:
Hasegawa, Kishino, Yano (1985), J. Mol. Evol. 22 (2): 160–17... |
Tamura 1992 model. Extending Kimura ( 1980 ) model for the case where a G + C - content bias exists. Link: Tamura K ( 1992 ) Mol. Biol. Evol. 9 ( 4 ): 678–687. DOI: 10. 1093/ oxfordjournals. molbev. a040752 | def T92(mu=1.0, pi_GC=0.5, kappa=0.1, **kwargs):
"""
Tamura 1992 model. Extending Kimura (1980) model for the case where a
G+C-content bias exists. Link:
Tamura K (1992), Mol. Biol. Evol. 9 (4): 678–687. DOI: 10.1093/oxfordjournals.molbev.a040752
Current implementation of the model does not acc... |
Tamura and Nei 1993. The model distinguishes between the two different types of transition: ( A < - > G ) is allowed to have a different rate to ( C< - > T ). Transversions have the same rate. The frequencies of the nucleotides are allowed to be different. Link: Tamura Nei ( 1993 ) MolBiol Evol. 10 ( 3 ): 512–526. DOI:... | def TN93(mu=1.0, kappa1=1., kappa2=1., pi=None, **kwargs):
"""
Tamura and Nei 1993. The model distinguishes between the two different types of
transition: (A <-> G) is allowed to have a different rate to (C<->T).
Transversions have the same rate. The frequencies of the nucleotides are allowed
to be ... |
Alphabet = [ A C G T ] | def _create_transversion_transition_W(kappa):
"""
Alphabet = [A, C, G, T]
"""
W = np.ones((4,4))
W[0, 2]=W[1, 3]=W[2, 0]=W[3,1]=kappa
return W |
initialize the merger model with a coalescent time | def set_Tc(self, Tc, T=None):
'''
initialize the merger model with a coalescent time
Args:
- Tc: a float or an iterable, if iterable another argument T of same shape is required
- T: an array like of same shape as Tc that specifies the time pivots corresponding to T... |
calculates an interpolation object that maps time to the number of concurrent branches in the tree. The result is stored in self. nbranches | def calc_branch_count(self):
'''
calculates an interpolation object that maps time to the number of
concurrent branches in the tree. The result is stored in self.nbranches
'''
# make a list of (time, merger or loss event) by root first iteration
self.tree_events = np.arr... |
calculates the integral int_0^t ( k ( t ) - 1 )/ 2Tc ( t ) dt and stores it as self. integral_merger_rate. This differences of this quantity evaluated at different times points are the cost of a branch. | def calc_integral_merger_rate(self):
'''
calculates the integral int_0^t (k(t')-1)/2Tc(t') dt' and stores it as
self.integral_merger_rate. This differences of this quantity evaluated at
different times points are the cost of a branch.
'''
# integrate the piecewise constan... |
returns the cost associated with a branch starting at t_node t_node is time before present the branch goes back in time | def cost(self, t_node, branch_length, multiplicity=2.0):
'''
returns the cost associated with a branch starting at t_node
t_node is time before present, the branch goes back in time
Args:
- t_node: time of the node
- branch_length: branch length, det... |
attaches the the merger cost to each branch length interpolator in the tree. | def attach_to_tree(self):
'''
attaches the the merger cost to each branch length interpolator in the tree.
'''
for clade in self.tree.find_clades():
if clade.up is not None:
clade.branch_length_interpolator.merger_cost = self.cost |
determines the coalescent time scale that optimizes the coalescent likelihood of the tree | def optimize_Tc(self):
'''
determines the coalescent time scale that optimizes the coalescent likelihood of the tree
'''
from scipy.optimize import minimize_scalar
initial_Tc = self.Tc
def cost(Tc):
self.set_Tc(Tc)
return -self.total_LH()
... |
optimize the trajectory of the merger rate 1./ T_c to maximize the coalescent likelihood. parameters: n_points -- number of pivots of the Tc interpolation object stiffness -- penalty for rapid changes in log ( Tc ) methods -- method used to optimize tol -- optimization tolerance regularization -- cost of moving logTc o... | def optimize_skyline(self, n_points=20, stiffness=2.0, method = 'SLSQP',
tol=0.03, regularization=10.0, **kwarks):
'''
optimize the trajectory of the merger rate 1./T_c to maximize the
coalescent likelihood.
parameters:
n_points -- number of pivot... |
returns the skyline i. e. an estimate of the inverse rate of coalesence. Here the skyline is estimated from a sliding window average of the observed mergers i. e. without reference to the coalescence likelihood. parameters: gen -- number of generations per year. | def skyline_empirical(self, gen=1.0, n_points = 20):
'''
returns the skyline, i.e., an estimate of the inverse rate of coalesence.
Here, the skyline is estimated from a sliding window average of the observed
mergers, i.e., without reference to the coalescence likelihood.
paramete... |
return the skyline i. e. an estimate of the inverse rate of coalesence. This function merely returns the merger rate self. Tc that was set or estimated by other means. If it was determined using self. optimize_skyline the returned skyline will maximize the coalescent likelihood. parameters: gen -- number of generations... | def skyline_inferred(self, gen=1.0, confidence=False):
'''
return the skyline, i.e., an estimate of the inverse rate of coalesence.
This function merely returns the merger rate self.Tc that was set or
estimated by other means. If it was determined using self.optimize_skyline,
the... |
Take the raw sequence substitute the overhanging gaps with N ( missequenced ) and convert the sequence to the numpy array of chars. | def seq2array(seq, fill_overhangs=True, ambiguous_character='N'):
"""
Take the raw sequence, substitute the "overhanging" gaps with 'N' (missequenced),
and convert the sequence to the numpy array of chars.
Parameters
----------
seq : Biopython.SeqRecord, str, iterable
Sequence as an ob... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.