INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Load in Pageant CoverageDepth results with Ensembl loci. | def load_ensembl_coverage(cohort, coverage_path, min_tumor_depth, min_normal_depth=0,
pageant_dir_fn=None):
"""
Load in Pageant CoverageDepth results with Ensembl loci.
coverage_path is a path to Pageant CoverageDepth output directory, with
one subdirectory per patient and a `... |
Using the size of the y axis return a fraction of that size. | def vertical_percent(plot, percent=0.1):
"""
Using the size of the y axis, return a fraction of that size.
"""
plot_bottom, plot_top = plot.get_ylim()
return percent * (plot_top - plot_bottom) |
Hide tick values that are outside of [ min_tick_value max_tick_value ] | def hide_ticks(plot, min_tick_value=None, max_tick_value=None):
"""Hide tick values that are outside of [min_tick_value, max_tick_value]"""
for tick, tick_value in zip(plot.get_yticklabels(), plot.get_yticks()):
tick_label = as_numeric(tick_value)
if tick_label:
if (min_tick_value is... |
Add a p - value significance indicator. | def add_significance_indicator(plot, col_a=0, col_b=1, significant=False):
"""
Add a p-value significance indicator.
"""
plot_bottom, plot_top = plot.get_ylim()
# Give the plot a little room for the significance indicator
line_height = vertical_percent(plot, 0.1)
# Add some extra spacing bel... |
Overlay a stripplot on top of a boxplot. | def stripboxplot(x, y, data, ax=None, significant=None, **kwargs):
"""
Overlay a stripplot on top of a boxplot.
"""
ax = sb.boxplot(
x=x,
y=y,
data=data,
ax=ax,
fliersize=0,
**kwargs
)
plot = sb.stripplot(
x=x,
y=y,
data=da... |
Perform a Fisher s exact test to compare to binary columns | def fishers_exact_plot(data, condition1, condition2, ax=None,
condition1_value=None,
alternative="two-sided", **kwargs):
"""
Perform a Fisher's exact test to compare to binary columns
Parameters
----------
data: Pandas dataframe
Dataframe to ret... |
Create a box plot comparing a condition and perform a Mann Whitney test to compare the distribution in condition A v B | def mann_whitney_plot(data,
condition,
distribution,
ax=None,
condition_value=None,
alternative="two-sided",
skip_plot=False,
**kwargs):
"""
Create a box plot... |
Create a ROC curve and compute the bootstrap AUC for the given variable and outcome | def roc_curve_plot(data, value_column, outcome_column, bootstrap_samples=100, ax=None):
"""Create a ROC curve and compute the bootstrap AUC for the given variable and outcome
Parameters
----------
data : Pandas dataframe
Dataframe to retrieve information from
value_column : str
Colu... |
Return full cache_dir according to following logic: - if cache_dir is a full path ( per path. isabs ) return that value - if not and if cache_root_dir is not None join two paths - otherwise log warnings and return None Separately if args or kwargs are given format cache_dir using kwargs | def get_cache_dir(cache_dir, cache_root_dir=None, *args, **kwargs):
"""
Return full cache_dir, according to following logic:
- if cache_dir is a full path (per path.isabs), return that value
- if not and if cache_root_dir is not None, join two paths
- otherwise, log warnings and return N... |
Utility script applying several regexs to a string. Intended to be used by strip_column_names. | def _strip_column_name(col_name, keep_paren_contents=True):
"""
Utility script applying several regexs to a string.
Intended to be used by `strip_column_names`.
This function will:
1. replace informative punctuation components with text
2. (optionally) remove text within parentheses
... |
Utility script for renaming pandas columns to patsy - friendly names. | def strip_column_names(cols, keep_paren_contents=True):
"""
Utility script for renaming pandas columns to patsy-friendly names.
Revised names have been:
- stripped of all punctuation and whitespace (converted to text or `_`)
- converted to lower case
Takes a list of column names, retur... |
Given an object and a dictionary give the object new attributes from that dictionary. | def set_attributes(obj, additional_data):
"""
Given an object and a dictionary, give the object new attributes from that dictionary.
Uses _strip_column_name to git rid of whitespace/uppercase/special characters.
"""
for key, value in additional_data.items():
if hasattr(obj, key):
... |
Construct a DataFrameHolder and then return either that or the DataFrame. | def return_obj(cols, df, return_cols=False):
"""Construct a DataFrameHolder and then return either that or the DataFrame."""
df_holder = DataFrameHolder(cols=cols, df=df)
return df_holder.return_self(return_cols=return_cols) |
Utility function to compare two abritrary provenance dicts returns number of discrepancies. | def compare_provenance(
this_provenance, other_provenance,
left_outer_diff = "In current but not comparison",
right_outer_diff = "In comparison but not current"):
"""Utility function to compare two abritrary provenance dicts
returns number of discrepancies.
Parameters
----------... |
Helper function to produce a single KM survival plot among observations in df by groups defined by condition_col. | def _plot_kmf_single(df,
condition_col,
survival_col,
censor_col,
threshold,
title,
xlabel,
ylabel,
ax,
with_condition_color,
... |
Plot survival curves by splitting the dataset into two groups based on condition_col. Report results for a log - rank test ( if two groups are plotted ) or CoxPH survival analysis ( if > 2 groups ) for association with survival. | def plot_kmf(df,
condition_col,
censor_col,
survival_col,
strata_col=None,
threshold=None,
title=None,
xlabel=None,
ylabel=None,
ax=None,
with_condition_color="#B38600",
no_cond... |
: type formatted_text: FormattedText | def concat(self, formatted_text):
""":type formatted_text: FormattedText"""
assert self._is_compatible(formatted_text), "Cannot concat text with different modes"
self.text += formatted_text.text
return self |
: type formatted_texts: list [ FormattedText ] | def join(self, formatted_texts):
""":type formatted_texts: list[FormattedText]"""
formatted_texts = list(formatted_texts) # so that after the first iteration elements are not lost if generator
for formatted_text in formatted_texts:
assert self._is_compatible(formatted_text), "Cannot... |
: type args: FormattedText: type kwargs: FormattedText | def concat(self, *args, **kwargs):
"""
:type args: FormattedText
:type kwargs: FormattedText
"""
for arg in args:
assert self.formatted_text._is_compatible(arg), "Cannot concat text with different modes"
self.format_args.append(arg.text)
for kwarg ... |
Parameters ---------- min_random_variants: optional int Minimum number of random variants to be generated per patient. max_random_variants: optional int Maximum number of random variants to be generated per patient. | def random_cohort(size, cache_dir, data_dir=None,
min_random_variants=None,
max_random_variants=None,
seed_val=1234):
"""
Parameters
----------
min_random_variants: optional, int
Minimum number of random variants to be generated per patient.
... |
Generate a random collection of missense variants by trying random variants repeatedly. | def generate_random_missense_variants(num_variants=10, max_search=100000, reference="GRCh37"):
"""
Generate a random collection of missense variants by trying random variants repeatedly.
"""
variants = []
for i in range(max_search):
bases = ["A", "C", "T", "G"]
random_ref = choice(ba... |
Output a very simple metadata - free VCF for each variant in a variant_collection. | def generate_simple_vcf(filename, variant_collection):
"""
Output a very simple metadata-free VCF for each variant in a variant_collection.
"""
contigs = []
positions = []
refs = []
alts = []
for variant in variant_collection:
contigs.append("chr" + variant.contig)
positi... |
Looks up folder contents of path. | def list_folder(self, path):
"""Looks up folder contents of `path.`"""
# Inspired by https://github.com/rspivak/sftpserver/blob/0.3/src/sftpserver/stub_sftp.py#L70
try:
folder_contents = []
for f in os.listdir(path):
attr = paramiko.SFTPAttributes.from_sta... |
Filter variants from the Variant Collection | def filter_variants(variant_collection, patient, filter_fn, **kwargs):
"""Filter variants from the Variant Collection
Parameters
----------
variant_collection : varcode.VariantCollection
patient : cohorts.Patient
filter_fn: function
Takes a FilterableVariant and returns a boolean. Only ... |
Filter variants from the Effect Collection | def filter_effects(effect_collection, variant_collection, patient, filter_fn, all_effects, **kwargs):
"""Filter variants from the Effect Collection
Parameters
----------
effect_collection : varcode.EffectCollection
variant_collection : varcode.VariantCollection
patient : cohorts.Patient
fil... |
Count lines in a file | def count_lines_in(filename):
"Count lines in a file"
f = open(filename)
lines = 0
buf_size = 1024 * 1024
read_f = f.read # loop optimization
buf = read_f(buf_size)
while buf:
lines += buf.count('\n')
buf = read_f(buf_size)
return lines |
Resolve a path to the full python module name of the related view function | def view_name_from(path):
"Resolve a path to the full python module name of the related view function"
try:
return CACHED_VIEWS[path]
except KeyError:
view = resolve(path)
module = path
name = ''
if hasattr(view.func, '__module__'):
module = resol... |
Output a nicely formatted ascii table | def generate_table_from(data):
"Output a nicely formatted ascii table"
table = Texttable(max_width=120)
table.add_row(["view", "method", "status", "count", "minimum", "maximum", "mean", "stdev", "queries", "querytime"])
table.set_cols_align(["l", "l", "l", "r", "r", "r", "r", "r", "r", "r"])
for i... |
Given a log file and regex group and extract the performance data | def analyze_log_file(logfile, pattern, reverse_paths=True, progress=True):
"Given a log file and regex group and extract the performance data"
if progress:
lines = count_lines_in(logfile)
pbar = ProgressBar(widgets=[Percentage(), Bar()], maxval=lines+1).start()
counter = 0
data ... |
Create a string representation of this collection showing up to limit items. | def to_string(self, limit=None):
"""
Create a string representation of this collection, showing up to
`limit` items.
"""
header = self.short_string()
if len(self) == 0:
return header
contents = ""
element_lines = [
" -- %s" % (elem... |
: rtype: UserStorageHandler | def get_instance(cls, state):
""":rtype: UserStorageHandler"""
if cls.instance is None:
cls.instance = UserStorageHandler(state)
return cls.instance |
May contain sensitive info ( like user ids ). Use with care. | def _get_active_threads_names():
"""May contain sensitive info (like user ids). Use with care."""
active_threads = threading.enumerate()
return FormattedText().join(
[
FormattedText().newline().normal(" - {name}").start_format().bold(name=thread.name).end_format()
... |
May contain sensitive info ( like user ids ). Use with care. | def _get_running_workers_names(running_workers: list):
"""May contain sensitive info (like user ids). Use with care."""
return FormattedText().join(
[
FormattedText().newline().normal(" - {name}").start_format().bold(name=worker.name).end_format()
for worker i... |
May contain sensitive info ( like user ids ). Use with care. | def _get_worker_pools_names(worker_pools: list):
"""May contain sensitive info (like user ids). Use with care."""
return FormattedText().join(
[
FormattedText().newline().normal(" - {name}").start_format().bold(name=worker.name).end_format()
for worker in work... |
: param member_info: If True adds also chat member info. Please note that this additional info requires to make ONE api call. | def format(self, member_info: bool = False):
"""
:param member_info: If True, adds also chat member info. Please, note that this additional info requires
to make ONE api call.
"""
user = self.api_object
self.__format_user(user)
if member_info and self.chat.typ... |
Log error failing silently on error | def safe_log_error(self, error: Exception, *info: str):
"""Log error failing silently on error"""
self.__do_safe(lambda: self.logger.error(error, *info)) |
Log info failing silently on error | def safe_log_info(self, *info: str):
"""Log info failing silently on error"""
self.__do_safe(lambda: self.logger.info(*info)) |
implements the wald - wolfowitz runs test: http:// en. wikipedia. org/ wiki/ Wald - Wolfowitz_runs_test http:// support. sas. com/ kb/ 33/ 092. html | def wald_wolfowitz(sequence):
"""
implements the wald-wolfowitz runs test:
http://en.wikipedia.org/wiki/Wald-Wolfowitz_runs_test
http://support.sas.com/kb/33/092.html
:param sequence: any iterable with at most 2 values. e.g.
'1001001'
[1, 0, 1, 0, 1]
... |
test for the autocorrelation of a sequence between t and t - 1 as the auto_correlation it is less likely that the sequence is generated randomly.: param sequence: any iterable with at most 2 values that can be turned into a float via np. float. e. g. 1001001 [ 1 0 1 0 1 ] [ 1. 2. 1. 5 1 ]: rtype: returns a dict of the ... | def auto_correlation(sequence):
"""
test for the autocorrelation of a sequence between t and t - 1
as the 'auto_correlation' it is less likely that the sequence is
generated randomly.
:param sequence: any iterable with at most 2 values that can be turned
into a float via np.floa... |
Parse the links from a Link: header field. | def _parse_header_links(response):
"""
Parse the links from a Link: header field.
.. todo:: Links with the same relation collide at the moment.
:param bytes value: The header value.
:rtype: `dict`
:return: A dictionary of parsed links, keyed by ``rel`` or ``url``.
"""
values = respon... |
Make a client if we didn t get one. | def _default_client(jws_client, reactor, key, alg):
"""
Make a client if we didn't get one.
"""
if jws_client is None:
pool = HTTPConnectionPool(reactor)
agent = Agent(reactor, pool=pool)
jws_client = JWSClient(HTTPClient(agent=agent), key, alg)
return jws_client |
Find a challenge combination that consists of a single challenge that the responder can satisfy. | def _find_supported_challenge(authzr, responders):
"""
Find a challenge combination that consists of a single challenge that the
responder can satisfy.
:param ~acme.messages.AuthorizationResource auth: The authorization to
examine.
:type responder: List[`~txacme.interfaces.IResponder`]
... |
Complete an authorization using a responder. | def answer_challenge(authzr, client, responders):
"""
Complete an authorization using a responder.
:param ~acme.messages.AuthorizationResource auth: The authorization to
complete.
:param .Client client: The ACME client.
:type responders: List[`~txacme.interfaces.IResponder`]
:param res... |
Poll an authorization until it is in a state other than pending or processing. | def poll_until_valid(authzr, clock, client, timeout=300.0):
"""
Poll an authorization until it is in a state other than pending or
processing.
:param ~acme.messages.AuthorizationResource auth: The authorization to
complete.
:param clock: The ``IReactorTime`` implementation to use; usually t... |
Construct a client from an ACME directory at a given URL. | def from_url(cls, reactor, url, key, alg=RS256, jws_client=None):
"""
Construct a client from an ACME directory at a given URL.
:param url: The ``twisted.python.url.URL`` to fetch the directory from.
See `txacme.urls` for constants for various well-known public
directori... |
Create a new registration with the ACME server. | def register(self, new_reg=None):
"""
Create a new registration with the ACME server.
:param ~acme.messages.NewRegistration new_reg: The registration message
to use, or ``None`` to construct one.
:return: The registration resource.
:rtype: Deferred[`~acme.messages.R... |
Get the Location: if there is one. | def _maybe_location(cls, response, uri=None):
"""
Get the Location: if there is one.
"""
location = response.headers.getRawHeaders(b'location', [None])[0]
if location is not None:
return location.decode('ascii')
return uri |
If the registration already exists we should just load it. | def _maybe_registered(self, failure, new_reg):
"""
If the registration already exists, we should just load it.
"""
failure.trap(ServerError)
response = failure.value.response
if response.code == http.CONFLICT:
reg = new_reg.update(
resource=mes... |
Accept the terms - of - service for a registration. | def agree_to_tos(self, regr):
"""
Accept the terms-of-service for a registration.
:param ~acme.messages.RegistrationResource regr: The registration to
update.
:return: The updated registration resource.
:rtype: Deferred[`~acme.messages.RegistrationResource`]
... |
Submit a registration to the server to update it. | def update_registration(self, regr, uri=None):
"""
Submit a registration to the server to update it.
:param ~acme.messages.RegistrationResource regr: The registration to
update. Can be a :class:`~acme.messages.NewRegistration` instead,
in order to create a new registrat... |
Parse a registration response from the server. | def _parse_regr_response(self, response, uri=None, new_authzr_uri=None,
terms_of_service=None):
"""
Parse a registration response from the server.
"""
links = _parse_header_links(response)
if u'terms-of-service' in links:
terms_of_service ... |
Check that a registration response contains the registration we were expecting. | def _check_regr(self, regr, new_reg):
"""
Check that a registration response contains the registration we were
expecting.
"""
body = getattr(new_reg, 'body', new_reg)
for k, v in body.items():
if k == 'resource' or not v:
continue
i... |
Create a new authorization. | def request_challenges(self, identifier):
"""
Create a new authorization.
:param ~acme.messages.Identifier identifier: The identifier to
authorize.
:return: The new authorization resource.
:rtype: Deferred[`~acme.messages.AuthorizationResource`]
"""
... |
Ensure we got the expected response code. | def _expect_response(cls, response, code):
"""
Ensure we got the expected response code.
"""
if response.code != code:
raise errors.ClientError(
'Expected {!r} response but got {!r}'.format(
code, response.code))
return response |
Parse an authorization resource. | def _parse_authorization(cls, response, uri=None):
"""
Parse an authorization resource.
"""
links = _parse_header_links(response)
try:
new_cert_uri = links[u'next'][u'url']
except KeyError:
raise errors.ClientError('"next" link missing')
re... |
Check that the authorization we got is the one we expected. | def _check_authorization(cls, authzr, identifier):
"""
Check that the authorization we got is the one we expected.
"""
if authzr.body.identifier != identifier:
raise errors.UnexpectedUpdate(authzr)
return authzr |
Respond to an authorization challenge. | def answer_challenge(self, challenge_body, response):
"""
Respond to an authorization challenge.
:param ~acme.messages.ChallengeBody challenge_body: The challenge being
responded to.
:param ~acme.challenges.ChallengeResponse response: The response to the
challeng... |
Parse a challenge resource. | def _parse_challenge(cls, response):
"""
Parse a challenge resource.
"""
links = _parse_header_links(response)
try:
authzr_uri = links['up']['url']
except KeyError:
raise errors.ClientError('"up" link missing')
return (
response... |
Check that the challenge resource we got is the one we expected. | def _check_challenge(cls, challenge, challenge_body):
"""
Check that the challenge resource we got is the one we expected.
"""
if challenge.uri != challenge_body.uri:
raise errors.UnexpectedUpdate(challenge.uri)
return challenge |
Update an authorization from the server ( usually to check its status ). | def poll(self, authzr):
"""
Update an authorization from the server (usually to check its status).
"""
action = LOG_ACME_POLL_AUTHORIZATION(authorization=authzr)
with action.context():
return (
DeferredContext(self._client.get(authzr.uri))
... |
Parse the Retry - After value from a response. | def retry_after(cls, response, default=5, _now=time.time):
"""
Parse the Retry-After value from a response.
"""
val = response.headers.getRawHeaders(b'retry-after', [default])[0]
try:
return int(val)
except ValueError:
return http.stringToDatetime(... |
Request a certificate. | def request_issuance(self, csr):
"""
Request a certificate.
Authorizations should have already been completed for all of the names
requested in the CSR.
Note that unlike `acme.client.Client.request_issuance`, the certificate
resource will have the body data as raw bytes... |
Parse a response containing a certificate resource. | def _parse_certificate(cls, response):
"""
Parse a response containing a certificate resource.
"""
links = _parse_header_links(response)
try:
cert_chain_uri = links[u'up'][u'url']
except KeyError:
cert_chain_uri = None
return (
... |
Fetch the intermediary chain for a certificate. | def fetch_chain(self, certr, max_length=10):
"""
Fetch the intermediary chain for a certificate.
:param acme.messages.CertificateResource certr: The certificate to
fetch the chain for.
:param int max_length: The maximum length of the chain that will be
fetched.
... |
Wrap JSONDeSerializable object in JWS. | def _wrap_in_jws(self, nonce, obj):
"""
Wrap ``JSONDeSerializable`` object in JWS.
.. todo:: Implement ``acmePath``.
:param ~josepy.interfaces.JSONDeSerializable obj:
:param bytes nonce:
:rtype: `bytes`
:return: JSON-encoded data
"""
with LOG_J... |
Check response content and its type. | def _check_response(cls, response, content_type=JSON_CONTENT_TYPE):
"""
Check response content and its type.
.. note::
Unlike :mod:`acme.client`, checking is strict.
:param bytes content_type: Expected Content-Type response header. If
the response Content-Typ... |
Send HTTP request. | def _send_request(self, method, url, *args, **kwargs):
"""
Send HTTP request.
:param str method: The HTTP method to use.
:param str url: The URL to make the request to.
:return: Deferred firing with the HTTP response.
"""
action = LOG_JWS_REQUEST(url=url)
... |
Send HEAD request without checking the response. | def head(self, url, *args, **kwargs):
"""
Send HEAD request without checking the response.
Note that ``_check_response`` is not called, as there will be no
response body to check.
:param str url: The URL to make the request to.
"""
with LOG_JWS_HEAD().context():... |
Send GET request and check response. | def get(self, url, content_type=JSON_CONTENT_TYPE, **kwargs):
"""
Send GET request and check response.
:param str method: The HTTP method to use.
:param str url: The URL to make the request to.
:raises txacme.client.ServerError: If server response body carries HTTP
... |
Store a nonce from a response we received. | def _add_nonce(self, response):
"""
Store a nonce from a response we received.
:param twisted.web.iweb.IResponse response: The HTTP response.
:return: The response, unmodified.
"""
nonce = response.headers.getRawHeaders(
REPLAY_NONCE_HEADER, [None])[0]
... |
Get a nonce to use in a request removing it from the nonces on hand. | def _get_nonce(self, url):
"""
Get a nonce to use in a request, removing it from the nonces on hand.
"""
action = LOG_JWS_GET_NONCE()
if len(self._nonces) > 0:
with action:
nonce = self._nonces.pop()
action.add_success_fields(nonce=nonc... |
POST an object and check the response. | def _post(self, url, obj, content_type, **kwargs):
"""
POST an object and check the response.
:param str url: The URL to request.
:param ~josepy.interfaces.JSONDeSerializable obj: The serializable
payload of the request.
:param bytes content_type: The expected conten... |
POST an object and check the response. Retry once if a badNonce error is received. | def post(self, url, obj, content_type=JSON_CONTENT_TYPE, **kwargs):
"""
POST an object and check the response. Retry once if a badNonce error
is received.
:param str url: The URL to request.
:param ~josepy.interfaces.JSONDeSerializable obj: The serializable
payload o... |
Create a threading. Thread but always set daemon. | def _daemon_thread(*a, **kw):
"""
Create a `threading.Thread`, but always set ``daemon``.
"""
thread = Thread(*a, **kw)
thread.daemon = True
return thread |
Run a task in a worker delivering the result as a Deferred in the reactor thread. | def _defer_to_worker(deliver, worker, work, *args, **kwargs):
"""
Run a task in a worker, delivering the result as a ``Deferred`` in the
reactor thread.
"""
deferred = Deferred()
def wrapped_work():
try:
result = work(*args, **kwargs)
except BaseException:
... |
Split the zone portion off from a DNS label. | def _split_zone(server_name, zone_name):
"""
Split the zone portion off from a DNS label.
:param str server_name: The full DNS label.
:param str zone_name: The zone name suffix.
"""
server_name = server_name.rstrip(u'.')
zone_name = zone_name.rstrip(u'.')
if not (server_name == zone_nam... |
Get existing validation records. | def _get_existing(driver, zone_name, server_name, validation):
"""
Get existing validation records.
"""
if zone_name is None:
zones = sorted(
(z for z
in driver.list_zones()
if server_name.rstrip(u'.')
.endswith(u'.' + z.domain.rstrip(u'.')))... |
Get the validation value for a challenge response. | def _validation(response):
"""
Get the validation value for a challenge response.
"""
h = hashlib.sha256(response.key_authorization.encode("utf-8"))
return b64encode(h.digest()).decode() |
Load the client key from a directory creating it if it does not exist. | def load_or_create_client_key(pem_path):
"""
Load the client key from a directory, creating it if it does not exist.
.. note:: The client key that will be created will be a 2048-bit RSA key.
:type pem_path: ``twisted.python.filepath.FilePath``
:param pem_path: The certificate directory
to ... |
Parse a txacme endpoint description. | def _parse(reactor, directory, pemdir, *args, **kwargs):
"""
Parse a txacme endpoint description.
:param reactor: The Twisted reactor.
:param directory: ``twisted.python.url.URL`` for the ACME directory to use
for issuing certs.
:param str pemdir: The path to the certificate directory to us... |
Generator which continually reads f to the next instance of delimiter. | def lazyread(f, delimiter):
"""
Generator which continually reads ``f`` to the next instance
of ``delimiter``.
This allows you to do batch processing on the contents of ``f`` without
loading the entire file into memory.
:param f: Any file-like object which has a ``.read()`` method.
:param ... |
Generate a random private key using sensible parameters. | def generate_private_key(key_type):
"""
Generate a random private key using sensible parameters.
:param str key_type: The type of key to generate. One of: ``rsa``.
"""
if key_type == u'rsa':
return rsa.generate_private_key(
public_exponent=65537, key_size=2048, backend=default_b... |
Generate a certificate/ key pair for responding to a tls - sni - 01 challenge. | def generate_tls_sni_01_cert(server_name, key_type=u'rsa',
_generate_private_key=None):
"""
Generate a certificate/key pair for responding to a tls-sni-01 challenge.
:param str server_name: The SAN the certificate should have.
:param str key_type: The type of key to generat... |
Tap a Deferred callback chain with a function whose return value is ignored. | def tap(f):
"""
"Tap" a Deferred callback chain with a function whose return value is
ignored.
"""
@wraps(f)
def _cb(res, *a, **kw):
d = maybeDeferred(f, res, *a, **kw)
d.addCallback(lambda ignored: res)
return d
return _cb |
Decode JOSE Base - 64 DER - encoded CSR. | def decode_csr(b64der):
"""
Decode JOSE Base-64 DER-encoded CSR.
:param str b64der: The encoded CSR.
:rtype: `cryptography.x509.CertificateSigningRequest`
:return: The decoded CSR.
"""
try:
return x509.load_der_x509_csr(
decode_b64jose(b64der), default_backend())
ex... |
Generate a certificate signing request for the given names and private key. | def csr_for_names(names, key):
"""
Generate a certificate signing request for the given names and private key.
.. seealso:: `acme.client.Client.request_issuance`
.. seealso:: `generate_private_key`
:param ``List[str]``: One or more names (subjectAltName) for which to
request a certifica... |
async wrapper is required to avoid await calls raising a SyntaxError | def _wrap_parse(code, filename):
"""
async wrapper is required to avoid await calls raising a SyntaxError
"""
code = 'async def wrapper():\n' + indent(code, ' ')
return ast.parse(code, filename=filename).body[0].body[0].value |
Determine the URL corresponding to Python object | def linkcode_resolve(domain, info):
"""
Determine the URL corresponding to Python object
"""
if domain != 'py':
return None
modname = info['module']
fullname = info['fullname']
submod = sys.modules.get(modname)
if submod is None:
return None
obj = submod
for part ... |
Sync n layers in Solr. | def layers_to_solr(self, layers):
"""
Sync n layers in Solr.
"""
layers_dict_list = []
layers_success_ids = []
layers_errors_ids = []
for layer in layers:
layer_dict, message = layer2dict(layer)
if not layer_dict:
layers_e... |
Sync a layer in Solr. | def layer_to_solr(self, layer):
"""
Sync a layer in Solr.
"""
success = True
message = 'Synced layer id %s to Solr' % layer.id
layer_dict, message = layer2dict(layer)
if not layer_dict:
success = False
else:
layer_json = json.dumps... |
Clear all indexes in the solr core | def clear_solr(self, catalog="hypermap"):
"""Clear all indexes in the solr core"""
solr_url = "{0}/solr/{1}".format(SEARCH_URL, catalog)
solr = pysolr.Solr(solr_url, timeout=60)
solr.delete(q='*:*')
LOGGER.debug('Solr core cleared') |
set the mapping in solr.: param catalog: core: return: | def update_schema(self, catalog="hypermap"):
"""
set the mapping in solr.
:param catalog: core
:return:
"""
schema_url = "{0}/solr/{1}/schema".format(SEARCH_URL, catalog)
print schema_url
# create a special type to draw better heatmaps.
location_r... |
Create a layer/ keyword list from a metadata record if it does not already exist. | def create_layer_from_metadata_xml(resourcetype, xml, monitor=False, service=None, catalog=None):
"""
Create a layer / keyword list from a metadata record if it does not already exist.
"""
from models import gen_anytext, Layer
if resourcetype == 'http://www.opengis.net/cat/csw/2.0.2': # Dublin cor... |
Create a service from an endpoint if it does not already exists. | def create_service_from_endpoint(endpoint, service_type, title=None, abstract=None, catalog=None):
"""
Create a service from an endpoint if it does not already exists.
"""
from models import Service
if Service.objects.filter(url=endpoint, catalog=catalog).count() == 0:
# check if endpoint is... |
Generate service/ services from an endpoint. WMS WMTS TMS endpoints correspond to a single service. ESRI CSW endpoints corrispond to many services.: return: imported message | def create_services_from_endpoint(url, catalog, greedy_opt=True):
"""
Generate service/services from an endpoint.
WMS, WMTS, TMS endpoints correspond to a single service.
ESRI, CSW endpoints corrispond to many services.
:return: imported, message
"""
# this variable will collect any excepti... |
Function that parses from url the service and folder of services. | def service_url_parse(url):
"""
Function that parses from url the service and folder of services.
"""
endpoint = get_sanitized_endpoint(url)
url_split_list = url.split(endpoint + '/')
if len(url_split_list) != 0:
url_split_list = url_split_list[1].split('/')
else:
raise Excep... |
Given coordinates in spherical mercator return a lon lat tuple. | def inverse_mercator(xy):
"""
Given coordinates in spherical mercator, return a lon,lat tuple.
"""
lon = (xy[0] / 20037508.34) * 180
lat = (xy[1] / 20037508.34) * 180
lat = 180 / math.pi * \
(2 * math.atan(math.exp(lat * math.pi / 180)) - math.pi / 2)
return (lon, lat) |
OWSLib wrapper function to perform version negotiation against owslib. wms. WebMapService | def get_wms_version_negotiate(url, timeout=10):
"""
OWSLib wrapper function to perform version negotiation against owslib.wms.WebMapService
"""
try:
LOGGER.debug('Trying a WMS 1.3.0 GetCapabilities request')
return WebMapService(url, version='1.3.0', timeout=timeout)
except Exceptio... |
Sanitize an endpoint as removing unneeded parameters | def get_sanitized_endpoint(url):
"""
Sanitize an endpoint, as removing unneeded parameters
"""
# sanitize esri
sanitized_url = url.rstrip()
esri_string = '/rest/services'
if esri_string in url:
match = re.search(esri_string, sanitized_url)
sanitized_url = url[0:(match.start(0... |
A method to get a service name from an esri endpoint. For example: http:// example. com/ arcgis/ rest/ services/ myservice/ mylayer/ MapServer/ ?f = json Will return: myservice/ mylayer | def get_esri_service_name(url):
"""
A method to get a service name from an esri endpoint.
For example: http://example.com/arcgis/rest/services/myservice/mylayer/MapServer/?f=json
Will return: myservice/mylayer
"""
result = re.search('rest/services/(.*)/[MapServer|ImageServer]', url)
if resul... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.