_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q259100 | OMXPlayer.quit | validation | def quit(self):
"""
Quit the player, blocking until the process has died
"""
if self._process is None:
logger.debug('Quit was called after self._process had already been released')
return
try:
logger.debug('Quitting OMXPlayer')
process_group_id = os.getpgid(self._process.pid)
| python | {
"resource": ""
} |
q259101 | BlogDetailView.render_to_response | validation | def render_to_response(self, context, **response_kwargs):
"""
Returns a response with a template depending if the request is ajax
or not and it renders with the given context.
"""
if self.request.is_ajax():
template = self.page_template
else:
| python | {
"resource": ""
} |
q259102 | translate_value | validation | def translate_value(document_field, form_value):
"""
Given a document_field and a form_value this will translate the value
to the correct result for mongo to use.
"""
value = form_value
| python | {
"resource": ""
} |
q259103 | trim_field_key | validation | def trim_field_key(document, field_key):
"""
Returns the smallest delimited version of field_key that
is an attribute on document.
return (key, left_over_array)
"""
trimming = True
left_over_key_values = []
current_key = field_key
while trimming and current_key:
if hasattr(document, current_key):
trimming = False | python | {
"resource": ""
} |
q259104 | BaseMongoAdmin.has_edit_permission | validation | def has_edit_permission(self, request):
""" Can edit this object """
| python | {
"resource": ""
} |
q259105 | BaseMongoAdmin.has_add_permission | validation | def has_add_permission(self, request):
""" Can add this object """
| python | {
"resource": ""
} |
q259106 | BaseMongoAdmin.has_delete_permission | validation | def has_delete_permission(self, request):
""" Can delete this object """
| python | {
"resource": ""
} |
q259107 | MongoModelFormBaseMixin.set_form_fields | validation | def set_form_fields(self, form_field_dict, parent_key=None, field_type=None):
"""
Set the form fields for every key in the form_field_dict.
Params:
form_field_dict -- a dictionary created by get_form_field_dict
parent_key -- the key for the previous key in the recursive call
field_type -- used to determine what kind of field we are setting
"""
for form_key, field_value in form_field_dict.items():
form_key = make_key(parent_key, form_key) if parent_key is not None else form_key
if isinstance(field_value, tuple):
set_list_class = False
base_key = form_key
# Style list fields
if ListField in (field_value.field_type, field_type):
# Nested lists/embedded docs need special care to get
# styles to work out nicely.
if parent_key is None or ListField == field_value.field_type:
if field_type != EmbeddedDocumentField:
field_value.widget.attrs['class'] += ' listField {0}'.format(form_key)
set_list_class = True
else:
field_value.widget.attrs['class'] += ' listField'
# Compute number value for list key
list_keys = [field_key for field_key in self.form.fields.keys()
if has_digit(field_key)]
key_int = 0
while form_key in list_keys:
key_int += 1
form_key = make_key(form_key, key_int)
if parent_key is not None:
# Get the base key for our embedded field class
| python | {
"resource": ""
} |
q259108 | MongoModelFormBaseMixin.get_field_value | validation | def get_field_value(self, field_key):
"""
Given field_key will return value held at self.model_instance. If
model_instance has not been provided will return None.
"""
def get_value(document, field_key):
# Short circuit the function if we do not have a document
if document is None:
return None
current_key, new_key_array = trim_field_key(document, field_key)
key_array_digit = int(new_key_array[-1]) if new_key_array and has_digit(new_key_array) else None
new_key = make_key(new_key_array)
if key_array_digit is not None and len(new_key_array) > 0:
# Handleing list fields
if len(new_key_array) == 1:
return_data = document._data.get(current_key, [])
elif isinstance(document, BaseList):
return_list = []
if len(document) > 0:
return_list = [get_value(doc, new_key) for doc in document]
return_data = return_list
else:
| python | {
"resource": ""
} |
q259109 | has_digit | validation | def has_digit(string_or_list, sep="_"):
"""
Given a string or a list will return true if the last word or
element is a digit. sep is used when a string is given to know
what separates one word from another.
"""
if isinstance(string_or_list, (tuple, list)):
list_length = len(string_or_list)
if | python | {
"resource": ""
} |
q259110 | make_key | validation | def make_key(*args, **kwargs):
"""
Given any number of lists and strings will join them in order as one
string separated by the sep kwarg. sep defaults to u"_".
Add exclude_last_string=True as a kwarg to exclude the last item in a
given string after being split by sep. Note if you only have one word
in your string you can end up getting an empty string.
Example uses:
>>> from mongonaut.forms.form_utils import make_key
>>> make_key('hi', 'my', 'firend')
>>> u'hi_my_firend'
>>> make_key('hi', 'my', 'firend', sep='i')
>>> 'hiimyifirend'
>>> make_key('hi', 'my', 'firend',['this', 'be', 'what'], sep='i')
>>> 'hiimyifirendithisibeiwhat'
>>> make_key('hi', 'my', 'firend',['this', 'be', 'what'])
>>> u'hi_my_firend_this_be_what'
"""
sep = kwargs.get('sep', u"_")
exclude_last_string = kwargs.get('exclude_last_string', False)
string_array = []
| python | {
"resource": ""
} |
q259111 | MongoModelForm.set_fields | validation | def set_fields(self):
"""Sets existing data to form fields."""
# Get dictionary map of current model
if self.is_initialized:
self.model_map_dict = self.create_document_dictionary(self.model_instance)
else:
| python | {
"resource": ""
} |
q259112 | MongoModelForm.set_post_data | validation | def set_post_data(self):
"""
Need to set form data so that validation on all post data occurs and
places newly entered form data on the form object.
"""
self.form.data = self.post_data_dict
# Specifically adding list field keys to the form so they are included
# in form.cleaned_data after the call to is_valid
for field_key, field in self.form.fields.items():
if has_digit(field_key):
# We have a list field.
base_key = make_key(field_key, | python | {
"resource": ""
} |
q259113 | MongoModelForm.get_form | validation | def get_form(self):
"""
Generate the form for view.
"""
self.set_fields()
if self.post_data_dict is not | python | {
"resource": ""
} |
q259114 | MongoModelForm.create_list_dict | validation | def create_list_dict(self, document, list_field, doc_key):
"""
Genereates a dictionary representation of the list field. Document
should be the document the list_field comes from.
DO NOT CALL DIRECTLY
"""
list_dict = {"_document": document}
if isinstance(list_field.field, EmbeddedDocumentField):
list_dict.update(self.create_document_dictionary(document=list_field.field.document_type_obj,
owner_document=document))
# Set | python | {
"resource": ""
} |
q259115 | MongoModelForm.create_document_dictionary | validation | def create_document_dictionary(self, document, document_key=None,
owner_document=None):
"""
Given document generates a dictionary representation of the document.
Includes the widget for each for each field in the document.
"""
doc_dict = self.create_doc_dict(document, document_key, owner_document)
for doc_key, doc_field in doc_dict.items():
# Base fields should not be evaluated
if doc_key.startswith("_"):
continue
if isinstance(doc_field, ListField):
doc_dict[doc_key] = self.create_list_dict(document, doc_field, doc_key)
elif isinstance(doc_field, EmbeddedDocumentField):
| python | {
"resource": ""
} |
q259116 | get_widget | validation | def get_widget(model_field, disabled=False):
"""Choose which widget to display for a field."""
attrs = get_attrs(model_field, disabled)
if hasattr(model_field, "max_length") and not model_field.max_length:
return forms.Textarea(attrs=attrs)
elif isinstance(model_field, DateTimeField):
return forms.DateTimeInput(attrs=attrs)
elif isinstance(model_field, BooleanField):
return forms.CheckboxInput(attrs=attrs)
elif isinstance(model_field, ReferenceField) or model_field.choices:
| python | {
"resource": ""
} |
q259117 | get_attrs | validation | def get_attrs(model_field, disabled=False):
"""Set attributes on the display widget."""
attrs = {}
attrs['class'] = | python | {
"resource": ""
} |
q259118 | get_form_field_class | validation | def get_form_field_class(model_field):
"""Gets the default form field for a mongoenigne field."""
FIELD_MAPPING = {
IntField: forms.IntegerField,
StringField: forms.CharField,
| python | {
"resource": ""
} |
q259119 | DocumentListView.get_qset | validation | def get_qset(self, queryset, q):
"""Performs filtering against the default queryset returned by
mongoengine.
"""
if self.mongoadmin.search_fields and q:
params = {}
for field in self.mongoadmin.search_fields:
if field == 'id':
# check to make sure this is a valid ID, otherwise we just continue
if is_valid_object_id(q):
| python | {
"resource": ""
} |
q259120 | DocumentListView.get_context_data | validation | def get_context_data(self, **kwargs):
"""Injects data into the context to replicate CBV ListView."""
context = super(DocumentListView, self).get_context_data(**kwargs)
context = self.set_permissions_in_context(context)
if not context['has_view_permission']:
return HttpResponseForbidden("You do not have permissions to view this content.")
context['object_list'] = self.get_queryset()
context['document'] = self.document
context['app_label'] = self.app_label
context['document_name'] = self.document_name
context['request'] = self.request
# pagination bits
context['page'] = self.page
context['documents_per_page'] = self.documents_per_page
if self.page > 1:
previous_page_number = self.page - 1
else:
previous_page_number = None
if self.page < self.total_pages:
next_page_number = self.page + 1
else:
next_page_number = None
context['previous_page_number'] = previous_page_number
context['has_previous_page'] = previous_page_number is not None
context['next_page_number'] = next_page_number
context['has_next_page'] = next_page_number is not None
context['total_pages'] = self.total_pages
# Part of upcoming list view form functionality
if self.queryset.count():
| python | {
"resource": ""
} |
q259121 | DocumentListView.post | validation | def post(self, request, *args, **kwargs):
"""Creates new mongoengine records."""
# TODO - make sure to check the rights of the poster
#self.get_queryset() # TODO - write something that grabs the document class better
form_class = self.get_form_class()
form = self.get_form(form_class)
mongo_ids = self.get_initial()['mongo_id']
for form_mongo_id in form.data.getlist('mongo_id'): | python | {
"resource": ""
} |
q259122 | MongonautViewMixin.get_mongoadmins | validation | def get_mongoadmins(self):
""" Returns a list of all mongoadmin implementations for the site """
apps = []
for app_name in settings.INSTALLED_APPS:
mongoadmin = "{0}.mongoadmin".format(app_name)
try:
module = import_module(mongoadmin)
except ImportError as e:
if str(e).startswith("No module named"):
| python | {
"resource": ""
} |
q259123 | MongonautViewMixin.set_mongonaut_base | validation | def set_mongonaut_base(self):
""" Sets a number of commonly used attributes """
if hasattr(self, "app_label"):
# prevents us from calling this multiple times
return None
self.app_label = self.kwargs.get('app_label')
self.document_name = self.kwargs.get('document_name')
# TODO Allow this to be assigned via url variable
| python | {
"resource": ""
} |
q259124 | MongonautViewMixin.set_permissions_in_context | validation | def set_permissions_in_context(self, context={}):
""" Provides permissions for mongoadmin for use in the context"""
context['has_view_permission'] = self.mongoadmin.has_view_permission(self.request)
context['has_edit_permission'] = self.mongoadmin.has_edit_permission(self.request)
| python | {
"resource": ""
} |
q259125 | MongonautFormViewMixin.process_post_form | validation | def process_post_form(self, success_message=None):
"""
As long as the form is set on the view this method will validate the form
and save the submitted data. Only call this if you are posting data.
The given success_message will be used with the djanog messages framework
if the posted data sucessfully submits.
"""
# When on initial args are given we need to set the base document.
if not hasattr(self, 'document') or self.document is None:
self.document = self.document_type()
self.form = MongoModelForm(model=self.document_type, instance=self.document,
form_post_data=self.request.POST).get_form()
self.form.is_bound = True
if self.form.is_valid():
self.document_map_dict = MongoModelForm(model=self.document_type).create_document_dictionary(self.document_type)
self.new_document = self.document_type
# Used to keep track of embedded documents in lists. Keyed by the list and the number of the
# document.
self.embedded_list_docs = {}
if self.new_document is None:
messages.error(self.request, | python | {
"resource": ""
} |
q259126 | MongonautFormViewMixin.process_document | validation | def process_document(self, document, form_key, passed_key):
"""
Given the form_key will evaluate the document and set values correctly for
the document given.
"""
if passed_key is not None:
current_key, remaining_key_array = trim_field_key(document, passed_key)
else:
current_key, remaining_key_array = trim_field_key(document, form_key)
key_array_digit = remaining_key_array[-1] if remaining_key_array and has_digit(remaining_key_array) else None
remaining_key = make_key(remaining_key_array)
if current_key.lower() == 'id':
raise KeyError(u"Mongonaut does not work with models which have fields beginning with id_")
# Create boolean checks to make processing document easier
is_embedded_doc = (isinstance(document._fields.get(current_key, None), EmbeddedDocumentField)
if hasattr(document, '_fields') else False)
| python | {
"resource": ""
} |
q259127 | MongonautFormViewMixin.set_embedded_doc | validation | def set_embedded_doc(self, document, form_key, current_key, remaining_key):
"""Get the existing embedded document if it exists, else created it."""
embedded_doc = getattr(document, current_key, False)
if | python | {
"resource": ""
} |
q259128 | MongonautFormViewMixin.set_list_field | validation | def set_list_field(self, document, form_key, current_key, remaining_key, key_array_digit):
"""1. Figures out what value the list ought to have
2. Sets the list
"""
document_field = document._fields.get(current_key)
# Figure out what value the list ought to have
# None value for ListFields make mongoengine very un-happy
list_value = translate_value(document_field.field, self.form.cleaned_data[form_key])
if list_value is None or (not list_value and not bool(list_value)):
return None
current_list = getattr(document, current_key, None)
if isinstance(document_field.field, EmbeddedDocumentField):
embedded_list_key = u"{0}_{1}".format(current_key, key_array_digit)
| python | {
"resource": ""
} |
q259129 | with_tz | validation | def with_tz(request):
"""
Get the time with TZ enabled
"""
dt = datetime.now()
t = Template('{% load tz %}{% localtime on %}{% get_current_timezone as TIME_ZONE %}{{ | python | {
"resource": ""
} |
q259130 | without_tz | validation | def without_tz(request):
"""
Get the time without TZ enabled
"""
t = Template('{% load tz | python | {
"resource": ""
} |
q259131 | is_valid_ip | validation | def is_valid_ip(ip_address):
""" Check Validity of an IP address """
try:
ip = ipaddress.ip_address(u'' + ip_address)
| python | {
"resource": ""
} |
q259132 | is_local_ip | validation | def is_local_ip(ip_address):
""" Check if IP is local """
try:
ip = ipaddress.ip_address(u'' + ip_address)
| python | {
"resource": ""
} |
q259133 | EasyTimezoneMiddleware.process_request | validation | def process_request(self, request):
"""
If we can get a valid IP from the request,
look up that address in the database to get the appropriate timezone
and activate it.
Else, use the default.
"""
if not request:
return
if not db_loaded:
load_db()
tz = request.session.get('django_timezone')
if not tz:
# use the default timezone (settings.TIME_ZONE) for localhost
tz = timezone.get_default_timezone()
client_ip = get_ip_address_from_request(request)
ip_addrs = client_ip.split(',')
for ip in ip_addrs:
if is_valid_ip(ip) and not is_local_ip(ip):
if ':' in ip:
tz = db_v6.time_zone_by_addr(ip)
break
| python | {
"resource": ""
} |
q259134 | ElasticQuery.search | validation | def search(self):
""" This is the most important method """
try:
filters = json.loads(self.query)
except ValueError:
return False
result = self.model_query
if 'filter'in filters.keys():
result | python | {
"resource": ""
} |
q259135 | ElasticQuery.parse_filter | validation | def parse_filter(self, filters):
""" This method process the filters """
for filter_type in filters:
if filter_type == 'or' or filter_type == 'and':
conditions = []
for field in filters[filter_type]:
if self.is_field_allowed(field):
conditions.append(self.create_query(self.parse_field(field, filters[filter_type][field])))
if filter_type == 'or':
self.model_query = self.model_query.filter(or_(*conditions))
elif filter_type == 'and':
| python | {
"resource": ""
} |
q259136 | ElasticQuery.create_query | validation | def create_query(self, attr):
""" Mix all values and make the query """
field = attr[0]
operator = attr[1]
value = attr[2]
model = self.model
if '.' in field:
field_items = field.split('.')
field_name = getattr(model, field_items[0], None)
class_name = field_name.property.mapper.class_
| python | {
"resource": ""
} |
q259137 | SMTP_dummy.sendmail | validation | def sendmail(self, msg_from, msg_to, msg):
"""Remember the recipients."""
SMTP_dummy.msg_from = msg_from
| python | {
"resource": ""
} |
q259138 | parsemail | validation | def parsemail(raw_message):
"""Parse message headers, then remove BCC header."""
message = email.parser.Parser().parsestr(raw_message)
# Detect encoding
detected = chardet.detect(bytearray(raw_message, "utf-8"))
encoding = detected["encoding"]
print(">>> encoding {}".format(encoding))
for part in message.walk():
if part.get_content_maintype() == 'multipart':
continue
part.set_charset(encoding)
# Extract recipients | python | {
"resource": ""
} |
q259139 | _create_boundary | validation | def _create_boundary(message):
"""Add boundary parameter to multipart message if they are not present."""
if not message.is_multipart() or message.get_boundary() is not None:
return message
# HACK: Python2 lists do not natively have a `copy` method. Unfortunately,
# due to a bug in the Backport for the email module, the method
# `Message.set_boundary` converts the Message headers into a native list,
| python | {
"resource": ""
} |
q259140 | make_message_multipart | validation | def make_message_multipart(message):
"""Convert a message into a multipart message."""
if not message.is_multipart():
multipart_message = email.mime.multipart.MIMEMultipart('alternative')
for header_key in set(message.keys()):
# Preserve duplicate headers
| python | {
"resource": ""
} |
q259141 | convert_markdown | validation | def convert_markdown(message):
"""Convert markdown in message text to HTML."""
assert message['Content-Type'].startswith("text/markdown")
del message['Content-Type']
# Convert the text from markdown and then make the message multipart
message = make_message_multipart(message)
for payload_item in set(message.get_payload()):
# Assume the plaintext item is formatted with markdown.
# Add corresponding HTML version of the item as the last part of
# the multipart message (as per RFC 2046)
if payload_item['Content-Type'].startswith('text/plain'):
original_text = payload_item.get_payload()
| python | {
"resource": ""
} |
q259142 | addattachments | validation | def addattachments(message, template_path):
"""Add the attachments from the message from the commandline options."""
if 'attachment' not in message:
return message, 0
message = make_message_multipart(message)
attachment_filepaths = message.get_all('attachment', failobj=[])
template_parent_dir = os.path.dirname(template_path)
for attachment_filepath in attachment_filepaths:
attachment_filepath = os.path.expanduser(attachment_filepath.strip())
if not attachment_filepath:
continue
if not os.path.isabs(attachment_filepath):
# Relative paths are relative to the template's parent directory
attachment_filepath = os.path.join(template_parent_dir,
attachment_filepath)
normalized_path = os.path.abspath(attachment_filepath)
# Check that the attachment exists
if not os.path.exists(normalized_path):
print("Error: can't find attachment " + normalized_path)
sys.exit(1)
filename | python | {
"resource": ""
} |
q259143 | sendmail | validation | def sendmail(message, sender, recipients, config_filename):
"""Send email message using Python SMTP library."""
# Read config file from disk to get SMTP server host, port, username
if not hasattr(sendmail, "host"):
config = configparser.RawConfigParser()
config.read(config_filename)
sendmail.host = config.get("smtp_server", "host")
sendmail.port = config.getint("smtp_server", "port")
sendmail.username = config.get("smtp_server", "username")
sendmail.security = config.get("smtp_server", "security")
print(">>> Read SMTP server configuration from {}".format(
config_filename))
print(">>> host = {}".format(sendmail.host))
print(">>> port = {}".format(sendmail.port))
print(">>> username = {}".format(sendmail.username))
print(">>> security = {}".format(sendmail.security))
# Prompt for password
if not hasattr(sendmail, "password"):
if sendmail.security == "Dummy" or sendmail.username == "None":
sendmail.password = None
else:
prompt = ">>> password for {} on {}: ".format(sendmail.username,
sendmail.host)
| python | {
"resource": ""
} |
q259144 | create_sample_input_files | validation | def create_sample_input_files(template_filename,
database_filename,
config_filename):
"""Create sample template email and database."""
print("Creating sample template email {}".format(template_filename))
if os.path.exists(template_filename):
print("Error: file exists: " + template_filename)
sys.exit(1)
with io.open(template_filename, "w") as template_file:
template_file.write(
u"TO: {{email}}\n"
u"SUBJECT: Testing mailmerge\n"
u"FROM: My Self <myself@mydomain.com>\n"
u"\n"
u"Hi, {{name}},\n"
u"\n"
u"Your number is {{number}}.\n"
)
print("Creating sample database {}".format(database_filename))
if os.path.exists(database_filename):
print("Error: file exists: " + database_filename)
sys.exit(1)
with io.open(database_filename, "w") as database_file:
database_file.write(
u'email,name,number\n'
u'myself@mydomain.com,"Myself",17\n'
u'bob@bobdomain.com,"Bob",42\n'
)
print("Creating sample config file {}".format(config_filename))
if os.path.exists(config_filename):
print("Error: file exists: " + config_filename)
sys.exit(1)
with io.open(config_filename, "w") as config_file:
config_file.write(
u"# Example: GMail\n"
u"[smtp_server]\n"
u"host = smtp.gmail.com\n"
u"port = 465\n"
u"security = SSL/TLS\n"
u"username = YOUR_USERNAME_HERE\n"
u"#\n"
u"# Example: Wide open\n"
u"# [smtp_server]\n"
u"# host = open-smtp.example.com\n"
u"# port = 25\n"
u"# security = Never\n"
u"# username = None\n"
u"#\n"
u"# Example: University of Michigan\n"
| python | {
"resource": ""
} |
q259145 | cli | validation | def cli(sample, dry_run, limit, no_limit,
database_filename, template_filename, config_filename):
"""Command line interface."""
# pylint: disable=too-many-arguments
mailmerge.api.main(
sample=sample,
dry_run=dry_run,
limit=limit,
| python | {
"resource": ""
} |
q259146 | with_continuations | validation | def with_continuations(**c):
"""
A decorator for defining tail-call optimized functions.
Example
-------
@with_continuations()
def factorial(n, k, self=None):
return self(n-1, k*n) if n > 1 else k
@with_continuations()
def identity(x, self=None):
return x
@with_continuations(out=identity)
def factorial2(n, k, self=None, out=None):
return self(n-1, k*n) if n > 1 else out(k)
print(factorial(7,1))
print(factorial2(7,1))
| python | {
"resource": ""
} |
q259147 | parse_int_list | validation | def parse_int_list(string):
"""
Parses a string of numbers and ranges into a list of integers. Ranges
are separated by dashes and inclusive of both the start and end number.
Example:
parse_int_list("8 9 10,11-13") == [8,9,10,11,12,13]
"""
integers = []
for comma_part in string.split(","):
for substring in comma_part.split(" "):
if len(substring) == 0:
continue
if "-" in substring:
| python | {
"resource": ""
} |
q259148 | BasePeonyClient._get_base_url | validation | def _get_base_url(base_url, api, version):
"""
create the base url for the api
Parameters
----------
base_url : str
format of the base_url using {api} and {version}
api : str
name of the api to use
version : str
version of the api
Returns
-------
| python | {
"resource": ""
} |
q259149 | BasePeonyClient.request | validation | async def request(self, method, url, future,
headers=None,
session=None,
encoding=None,
**kwargs):
"""
Make requests to the REST API
Parameters
----------
future : asyncio.Future
Future used to return the response
method : str
Method to be used by the request
url : str
URL of the resource
headers : .oauth.PeonyHeaders
Custom headers (doesn't overwrite `Authorization` headers)
session : aiohttp.ClientSession, optional
Client session used to make the request
Returns
-------
data.PeonyResponse
Response to the request
"""
await self.setup
# prepare request arguments, particularly the headers
req_kwargs = await self.headers.prepare_request(
method=method,
url=url,
headers=headers,
proxy=self.proxy,
**kwargs
)
if encoding is None:
encoding = self.encoding | python | {
"resource": ""
} |
q259150 | BasePeonyClient.stream_request | validation | def stream_request(self, method, url, headers=None, _session=None,
*args, **kwargs):
"""
Make requests to the Streaming API
Parameters
----------
method : str
Method to be used by the request
url : str
URL of the resource
headers : dict
Custom headers (doesn't overwrite `Authorization` headers)
_session : aiohttp.ClientSession, optional
The session to use for this specific request, the session
given as argument of :meth:`__init__` is used by default
Returns
| python | {
"resource": ""
} |
q259151 | BasePeonyClient.get_tasks | validation | def get_tasks(self):
"""
Get the tasks attached to the instance
Returns
-------
list
List of tasks (:class:`asyncio.Task`)
"""
| python | {
"resource": ""
} |
q259152 | BasePeonyClient.run_tasks | validation | async def run_tasks(self):
""" Run the tasks attached to the instance """
tasks = self.get_tasks()
self._gathered_tasks = asyncio.gather(*tasks, loop=self.loop)
| python | {
"resource": ""
} |
q259153 | BasePeonyClient.close | validation | async def close(self):
""" properly close the client """
tasks = self._get_close_tasks()
if tasks:
| python | {
"resource": ""
} |
q259154 | PeonyClient._chunked_upload | validation | async def _chunked_upload(self, media, media_size,
path=None,
media_type=None,
media_category=None,
chunk_size=2**20,
**params):
"""
upload media in chunks
Parameters
----------
media : file object
a file object of the media
media_size : int
size of the media
path : str, optional
filename of the media
media_type : str, optional
mime type of the media
media_category : str, optional
twitter media category, must be used with ``media_type``
chunk_size : int, optional
size of a chunk in bytes
params : dict, optional
additional parameters of the request
Returns
-------
.data_processing.PeonyResponse
Response of the request
"""
if isinstance(media, bytes):
media = io.BytesIO(media)
chunk = media.read(chunk_size)
is_coro = asyncio.iscoroutine(chunk)
if is_coro:
chunk = await chunk
if media_type is None:
media_metadata = await utils.get_media_metadata(chunk, path)
media_type, media_category = media_metadata
elif media_category is None:
media_category = utils.get_category(media_type)
response = await self.upload.media.upload.post(
command="INIT",
| python | {
"resource": ""
} |
q259155 | PeonyClient.upload_media | validation | async def upload_media(self, file_,
media_type=None,
media_category=None,
chunked=None,
size_limit=None,
**params):
"""
upload a media on twitter
Parameters
----------
file_ : str or pathlib.Path or file
Path to the file or file object
media_type : str, optional
mime type of the media
media_category : str, optional
Twitter's media category of the media, must be used with
``media_type``
chunked : bool, optional
If True, force the use of the chunked upload for the media
size_limit : int, optional
If set, the media will be sent using a multipart upload if
its size is over ``size_limit`` bytes
params : dict
parameters used when making the request
Returns
-------
.data_processing.PeonyResponse
| python | {
"resource": ""
} |
q259156 | _parse_iedb_response | validation | def _parse_iedb_response(response):
"""Take the binding predictions returned by IEDB's web API
and parse them into a DataFrame
Expect response to look like:
allele seq_num start end length peptide ic50 percentile_rank
HLA-A*01:01 1 2 10 9 LYNTVATLY 2145.70 3.7
HLA-A*01:01 1 5 13 9 TVATLYCVH 2216.49 3.9
HLA-A*01:01 1 7 15 9 ATLYCVHQR 2635.42 5.1
HLA-A*01:01 1 4 12 9 NTVATLYCV 6829.04 20
HLA-A*01:01 1 1 9 9 SLYNTVATL 8032.38 24
HLA-A*01:01 1 8 16 9 TLYCVHQRI 8853.90 26
HLA-A*01:01 1 3 11 9 YNTVATLYC 9865.62 29
HLA-A*01:01 1 6 14 9 VATLYCVHQ 27575.71 58
HLA-A*01:01 1 10 18 9 YCVHQRIDV 48929.64 74
HLA-A*01:01 1 9 17 9 LYCVHQRID 50000.00 75
"""
if len(response) == 0:
raise ValueError("Empty response from IEDB!")
df = pd.read_csv(io.BytesIO(response), delim_whitespace=True, header=0)
# pylint doesn't realize that df is a DataFrame, so tell is
assert type(df) == pd.DataFrame
df = pd.DataFrame(df)
if len(df) == 0:
raise ValueError(
"No binding predictions in response from IEDB: %s" % (response,))
required_columns = [
"allele",
| python | {
"resource": ""
} |
q259157 | IedbBasePredictor.predict_subsequences | validation | def predict_subsequences(self, sequence_dict, peptide_lengths=None):
"""Given a dictionary mapping unique keys to amino acid sequences,
run MHC binding predictions on all candidate epitopes extracted from
sequences and return a EpitopeCollection.
Parameters
----------
fasta_dictionary : dict or string
Mapping of protein identifiers to protein amino acid sequences.
If string then converted to dictionary.
"""
sequence_dict = check_sequence_dictionary(sequence_dict)
peptide_lengths = self._check_peptide_lengths(peptide_lengths)
# take each mutated sequence in the dataframe
# and general MHC binding scores for all k-mer substrings
binding_predictions = []
expected_peptides = set([])
normalized_alleles = []
for key, amino_acid_sequence in sequence_dict.items():
for l in peptide_lengths:
for i in range(len(amino_acid_sequence) - l + 1):
| python | {
"resource": ""
} |
q259158 | get_args | validation | def get_args(func, skip=0):
"""
Hackish way to get the arguments of a function
Parameters
----------
func : callable
Function to get the arguments from
skip : int, optional
Arguments to skip, defaults to 0 set it to 1 to skip the
``self`` argument of a method.
Returns
| python | {
"resource": ""
} |
q259159 | log_error | validation | def log_error(msg=None, exc_info=None, logger=None, **kwargs):
"""
log an exception and its traceback on the logger defined
Parameters
----------
msg : str, optional
A message to add to the error
exc_info : tuple
| python | {
"resource": ""
} |
q259160 | get_media_metadata | validation | async def get_media_metadata(data, path=None):
"""
Get all the file's metadata and read any kind of file object
Parameters
----------
data : bytes
first bytes of the file (the mimetype shoudl be guessed from the
file headers
path : str, optional
path to the file
Returns
-------
str
The mimetype of the media
str
The category of the media on Twitter
"""
if isinstance(data, bytes):
media_type = await get_type(data, path)
else:
| python | {
"resource": ""
} |
q259161 | get_size | validation | async def get_size(media):
"""
Get the size of a file
Parameters
----------
media : file object
The file object of the media
Returns
-------
int
The size of the file
"""
if hasattr(media, 'seek'):
await execute(media.seek(0, os.SEEK_END))
size = await execute(media.tell())
await execute(media.seek(0))
elif hasattr(media, 'headers'):
| python | {
"resource": ""
} |
q259162 | set_debug | validation | def set_debug():
""" activates error messages, useful during development """
| python | {
"resource": ""
} |
q259163 | BindingPrediction.clone_with_updates | validation | def clone_with_updates(self, **kwargs):
"""Returns new BindingPrediction with updated fields"""
fields_dict = self.to_dict()
| python | {
"resource": ""
} |
q259164 | IdIterator.get_data | validation | def get_data(self, response):
""" Get the data from the response """
if self._response_list:
return response
elif self._response_key is None:
if hasattr(response, "items"):
for key, data in response.items():
if (hasattr(data, "__getitem__")
and not hasattr(data, "items")
and len(data) > 0
and 'id' in data[0]):
self._response_key = key
| python | {
"resource": ""
} |
q259165 | SinceIdIterator.call_on_response | validation | async def call_on_response(self, data):
"""
Try to fill the gaps and strip last tweet from the response
if its id is that of the first tweet of the last response
Parameters
----------
data : list
The response data
"""
since_id = self.kwargs.get(self.param, 0) + 1
if self.fill_gaps:
| python | {
"resource": ""
} |
q259166 | get_oauth_token | validation | async def get_oauth_token(consumer_key, consumer_secret, callback_uri="oob"):
"""
Get a temporary oauth token
Parameters
----------
consumer_key : str
Your consumer key
consumer_secret : str
Your consumer secret
callback_uri : str, optional
Callback uri, defaults to 'oob'
Returns
-------
dict
Temporary tokens
"""
client = BasePeonyClient(consumer_key=consumer_key,
consumer_secret=consumer_secret, | python | {
"resource": ""
} |
q259167 | get_oauth_verifier | validation | async def get_oauth_verifier(oauth_token):
"""
Open authorize page in a browser,
print the url if it didn't work
Arguments
---------
oauth_token : str
The oauth token received in :func:`get_oauth_token`
Returns
-------
str
The PIN entered by the user
"""
url = "https://api.twitter.com/oauth/authorize?oauth_token=" + oauth_token
try:
browser = webbrowser.open(url) | python | {
"resource": ""
} |
q259168 | get_access_token | validation | async def get_access_token(consumer_key, consumer_secret,
oauth_token, oauth_token_secret,
oauth_verifier, **kwargs):
"""
get the access token of the user
Parameters
----------
consumer_key : str
Your consumer key
consumer_secret : str
Your consumer secret
oauth_token : str
OAuth token from :func:`get_oauth_token`
oauth_token_secret : str
OAuth token secret from :func:`get_oauth_token`
oauth_verifier : str
OAuth verifier from :func:`get_oauth_verifier`
Returns
-------
dict
Access tokens
"""
client = BasePeonyClient(consumer_key=consumer_key,
| python | {
"resource": ""
} |
q259169 | parse_token | validation | def parse_token(response):
"""
parse the responses containing the tokens
Parameters
----------
response : str
The response containing the tokens
Returns
-------
dict
The parsed tokens
"""
| python | {
"resource": ""
} |
q259170 | NetChop.predict | validation | def predict(self, sequences):
"""
Return netChop predictions for each position in each sequence.
Parameters
-----------
sequences : list of string
Amino acid sequences to predict cleavage for
Returns
-----------
list of list of float
The i'th list corresponds to the i'th sequence. Each list gives
the cleavage probability for each position in the sequence.
"""
with tempfile.NamedTemporaryFile(suffix=".fsa", mode="w") as input_fd:
| python | {
"resource": ""
} |
q259171 | NetChop.parse_netchop | validation | def parse_netchop(netchop_output):
"""
Parse netChop stdout.
"""
line_iterator = iter(netchop_output.decode().split("\n"))
scores = []
for line in line_iterator:
if "pos" in line and 'AA' in line and 'score' in line:
scores.append([])
if "----" not in next(line_iterator):
raise ValueError("Dashes expected")
| python | {
"resource": ""
} |
q259172 | BindingPredictionCollection.to_dataframe | validation | def to_dataframe(
self,
columns=BindingPrediction.fields + ("length",)):
"""
Converts collection of BindingPrediction objects to DataFrame
"""
| python | {
"resource": ""
} |
q259173 | NetMHC | validation | def NetMHC(alleles,
default_peptide_lengths=[9],
program_name="netMHC"):
"""
This function wraps NetMHC3 and NetMHC4 to automatically detect which class
to use. Currently based on running the '-h' command and looking for
discriminating substrings between the versions.
"""
# run NetMHC's help command and parse discriminating substrings out of
# the resulting str output
with open(os.devnull, 'w') as devnull:
help_output = check_output([program_name, "-h"], stderr=devnull)
help_output_str = help_output.decode("ascii", "ignore")
substring_to_netmhc_class = {
"-listMHC": NetMHC4,
"--Alleles": NetMHC3,
}
successes = []
for substring, netmhc_class in substring_to_netmhc_class.items():
if substring in help_output_str:
| python | {
"resource": ""
} |
q259174 | MHCflurry.predict_peptides | validation | def predict_peptides(self, peptides):
"""
Predict MHC affinity for peptides.
"""
# importing locally to avoid slowing down CLI applications which
# don't use MHCflurry
from mhcflurry.encodable_sequences import EncodableSequences
binding_predictions = []
encodable_sequences = EncodableSequences.create(peptides)
for allele in self.alleles:
predictions_df = self.predictor.predict_to_dataframe(
| python | {
"resource": ""
} |
q259175 | seq_to_str | validation | def seq_to_str(obj, sep=","):
"""
Given a sequence convert it to a comma separated string.
If, however, the argument is a single object, return its string | python | {
"resource": ""
} |
q259176 | create_input_peptides_files | validation | def create_input_peptides_files(
peptides,
max_peptides_per_file=None,
group_by_length=False):
"""
Creates one or more files containing one peptide per line,
returns names of files.
"""
if group_by_length:
peptide_lengths = {len(p) for p in peptides}
peptide_groups = {l: [] for l in peptide_lengths}
for p in peptides:
peptide_groups[len(p)].append(p)
else:
peptide_groups = {"": peptides}
file_names = []
for key, group in peptide_groups.items():
| python | {
"resource": ""
} |
q259177 | BasePredictor._check_peptide_lengths | validation | def _check_peptide_lengths(self, peptide_lengths=None):
"""
If peptide lengths not specified, then try using the default
lengths associated with this predictor object. If those aren't
a valid non-empty sequence of integers, then raise an exception.
Otherwise return the peptide lengths.
"""
if not peptide_lengths:
peptide_lengths = self.default_peptide_lengths
if not peptide_lengths:
raise ValueError(
("Must either provide 'peptide_lengths' argument "
"or set 'default_peptide_lengths"))
| python | {
"resource": ""
} |
q259178 | BasePredictor._check_peptide_inputs | validation | def _check_peptide_inputs(self, peptides):
"""
Check peptide sequences to make sure they are valid for this predictor.
"""
require_iterable_of(peptides, string_types)
check_X = not self.allow_X_in_peptides
check_lower = not self.allow_lowercase_in_peptides
check_min_length = self.min_peptide_length is not None
min_length = self.min_peptide_length
check_max_length = self.max_peptide_length is not None
max_length = self.max_peptide_length
for p in peptides:
| python | {
"resource": ""
} |
q259179 | BasePredictor.predict_subsequences | validation | def predict_subsequences(
self,
sequence_dict,
peptide_lengths=None):
"""
Given a dictionary mapping sequence names to amino acid strings,
and an optional list of peptide lengths, returns a
BindingPredictionCollection.
"""
if isinstance(sequence_dict, string_types):
sequence_dict = {"seq": sequence_dict}
elif isinstance(sequence_dict, (list, tuple)):
sequence_dict = {seq: seq for seq in sequence_dict}
peptide_lengths = self._check_peptide_lengths(peptide_lengths)
# convert long protein sequences to set of peptides and
# associated sequence name / offsets that each peptide may have come
# from
peptide_set = set([])
peptide_to_name_offset_pairs = defaultdict(list)
for name, sequence in sequence_dict.items():
for peptide_length in peptide_lengths:
for i in range(len(sequence) - peptide_length + 1):
peptide = sequence[i:i + peptide_length]
peptide_set.add(peptide)
peptide_to_name_offset_pairs[peptide].append((name, i))
| python | {
"resource": ""
} |
q259180 | BasePredictor._check_hla_alleles | validation | def _check_hla_alleles(
alleles,
valid_alleles=None):
"""
Given a list of HLA alleles and an optional list of valid
HLA alleles, return a set of alleles that we will pass into
the MHC binding predictor.
"""
require_iterable_of(alleles, string_types, "HLA alleles")
# Don't run the MHC predictor twice for homozygous alleles,
# only run it for unique alleles
alleles = {
normalize_allele_name(allele.strip().upper())
for allele in alleles
}
if valid_alleles:
| python | {
"resource": ""
} |
q259181 | StreamResponse._connect | validation | async def _connect(self):
"""
Connect to the stream
Returns
-------
asyncio.coroutine
The streaming response
"""
logger.debug("connecting to the stream")
await self.client.setup
if self.session is None:
| python | {
"resource": ""
} |
q259182 | StreamResponse.connect | validation | async def connect(self):
"""
Create the connection
Returns
-------
self
Raises
------
exception.PeonyException
On a response status in 4xx that are not status 420 or 429
Also on statuses in 1xx or 3xx since this should not be the status
received here
"""
with async_timeout.timeout(self.timeout):
self.response = await self._connect()
if self.response.status in range(200, 300):
self._error_timeout = 0
self.state = NORMAL
elif self.response.status == 500:
self.state = DISCONNECTION
| python | {
"resource": ""
} |
q259183 | Handler.with_prefix | validation | def with_prefix(self, prefix, strict=False):
"""
decorator to handle commands with prefixes
Parameters
----------
prefix : str
the prefix of the command
strict : bool, optional
If set to True the command must be | python | {
"resource": ""
} |
q259184 | BDClient.set_tz | validation | async def set_tz(self):
"""
set the environment timezone to the timezone
set in your twitter settings
"""
| python | {
"resource": ""
} |
q259185 | run_command | validation | def run_command(args, **kwargs):
"""
Given a list whose first element is a command name, followed by arguments,
execute it and show timing info.
| python | {
"resource": ""
} |
q259186 | run_multiple_commands_redirect_stdout | validation | def run_multiple_commands_redirect_stdout(
multiple_args_dict,
print_commands=True,
process_limit=-1,
polling_freq=0.5,
**kwargs):
"""
Run multiple shell commands in parallel, write each of their
stdout output to files associated with each command.
Parameters
----------
multiple_args_dict : dict
A dictionary whose keys are files and values are args list.
Run each args list as a subprocess and write stdout to the
corresponding file.
print_commands : bool
Print shell commands before running them.
process_limit : int
Limit the number of concurrent processes to this number. 0
if there is no limit, -1 to use max number of processors
polling_freq : int
Number of seconds between checking for done processes, if
we have a process limit
"""
assert len(multiple_args_dict) > 0
assert all(len(args) > 0 for args in multiple_args_dict.values())
assert all(hasattr(f, 'name') for f in multiple_args_dict.keys())
if process_limit < 0:
logger.debug("Using %d processes" % cpu_count())
process_limit = cpu_count()
start_time = time.time()
processes = Queue(maxsize=process_limit)
def add_to_queue(process):
process.start()
if print_commands:
handler = logging.FileHandler(process.redirect_stdout_file.name)
handler.setLevel(logging.DEBUG)
logger.addHandler(handler)
logger.debug(" ".join(process.args))
logger.removeHandler(handler)
processes.put(process)
for f, args in multiple_args_dict.items():
p = AsyncProcess(
args,
redirect_stdout_file=f,
**kwargs)
if not processes.full():
add_to_queue(p)
else:
while processes.full():
# Are there any done processes?
to_remove = []
| python | {
"resource": ""
} |
q259187 | loads | validation | def loads(json_data, encoding="utf-8", **kwargs):
"""
Custom loads function with an object_hook and automatic decoding
Parameters
----------
json_data : str
The JSON data to decode
*args
Positional arguments, passed to :func:`json.loads`
encoding : :obj:`str`, optional
The encoding of the bytestring
**kwargs
Keyword arguments | python | {
"resource": ""
} |
q259188 | read | validation | async def read(response, loads=loads, encoding=None):
"""
read the data of the response
Parameters
----------
response : aiohttp.ClientResponse
response
loads : callable
json loads function
encoding : :obj:`str`, optional
character encoding of the response, if set to None
aiohttp should guess the right encoding
Returns
-------
:obj:`bytes`, :obj:`str`, :obj:`dict` or :obj:`list`
the data returned depends on the response
"""
ctype = response.headers.get('Content-Type', "").lower()
try:
if "application/json" in ctype:
logger.info("decoding data as json")
return await response.json(encoding=encoding, loads=loads)
| python | {
"resource": ""
} |
q259189 | doc | validation | def doc(func):
"""
Find the message shown when someone calls the help command
Parameters
----------
func : function
the function
Returns
-------
str
The help message for this command
"""
stripped_chars = " \t"
if hasattr(func, '__doc__'):
docstring = func.__doc__.lstrip(" \n\t")
| python | {
"resource": ""
} |
q259190 | permission_check | validation | def permission_check(data, command_permissions,
command=None, permissions=None):
"""
Check the permissions of the user requesting a command
Parameters
----------
data : dict
message data
command_permissions : dict
permissions of the command, contains all the roles as key and users
with these permissions as values
command : function
the command that is run
permissions : tuple or list
| python | {
"resource": ""
} |
q259191 | main | validation | def main(args_list=None):
"""
Script to make pMHC binding predictions from amino acid sequences.
Usage example:
mhctools
--sequence SFFPIQQQQQAAALLLI \
--sequence SILQQQAQAQQAQAASSSC \
--extract-subsequences \
--mhc-predictor netmhc \
| python | {
"resource": ""
} |
q259192 | NetMHCIIpan._prepare_drb_allele_name | validation | def _prepare_drb_allele_name(self, parsed_beta_allele):
"""
Assume that we're dealing with a human DRB allele
which NetMHCIIpan treats differently because there is
little population diversity in the DR-alpha gene
"""
if "DRB" not in parsed_beta_allele.gene:
| python | {
"resource": ""
} |
q259193 | get_error | validation | def get_error(data):
""" return the error if there is a corresponding exception """
if isinstance(data, dict):
if 'errors' in data:
error = data['errors'][0]
else:
| python | {
"resource": ""
} |
q259194 | throw | validation | async def throw(response, loads=None, encoding=None, **kwargs):
""" Get the response data if possible and raise an exception """
if loads is None:
loads = data_processing.loads
data = await data_processing.read(response, loads=loads,
encoding=encoding)
error = get_error(data)
if error is not None:
exception = errors[error['code']]
| python | {
"resource": ""
} |
q259195 | ErrorDict.code | validation | def code(self, code):
""" Decorator to associate a code to an exception """
def decorator(exception):
| python | {
"resource": ""
} |
q259196 | PeonyHeaders.prepare_request | validation | async def prepare_request(self, method, url,
headers=None,
skip_params=False,
proxy=None,
**kwargs):
"""
prepare all the arguments for the request
Parameters
----------
method : str
HTTP method used by the request
url : str
The url to request
headers : dict, optional
Additionnal headers
proxy : str
proxy of the request
skip_params : bool
Don't use the parameters to sign the request
Returns
-------
dict
Parameters of the request correctly formatted
"""
if method.lower() == "post":
key = 'data'
else:
key = 'params'
| python | {
"resource": ""
} |
q259197 | PeonyHeaders._user_headers | validation | def _user_headers(self, headers=None):
""" Make sure the user doesn't override the Authorization header """
h = self.copy()
if headers is not None:
keys = set(headers.keys())
if h.get('Authorization', False):
| python | {
"resource": ""
} |
q259198 | process_keys | validation | def process_keys(func):
"""
Raise error for keys that are not strings
and add the prefix if it is missing
"""
@wraps(func)
def decorated(self, k, *args):
if not isinstance(k, str):
msg = "%s: key must be a string" % self.__class__.__name__
| python | {
"resource": ""
} |
q259199 | Functions._get | validation | def _get(self, text):
"""
Analyze the text to get the right function
Parameters
----------
text : str
The text that could call a function
"""
if self.strict:
match = self.prog.match(text)
if match:
cmd = match.group()
if cmd in self:
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.