sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def get_for_tag(self, tag):
"""
Returns queryset of Entry instances assigned to specified
tag, which can be a PK value, a slug value, or a Tag instance.
:param tag: tag PK, slug, or instance.
:rtype: django.db.models.query.QuerySet.
"""
tag_filter = {'tag': tag}
... | Returns queryset of Entry instances assigned to specified
tag, which can be a PK value, a slug value, or a Tag instance.
:param tag: tag PK, slug, or instance.
:rtype: django.db.models.query.QuerySet. | entailment |
def for_category(self, category, live_only=False):
"""
Returns queryset of EntryTag instances for specified category.
:param category: the Category instance.
:param live_only: flag to include only "live" entries.
:rtype: django.db.models.query.QuerySet.
"""
filte... | Returns queryset of EntryTag instances for specified category.
:param category: the Category instance.
:param live_only: flag to include only "live" entries.
:rtype: django.db.models.query.QuerySet. | entailment |
def related_to(self, entry, live_only=False):
"""
Returns queryset of Entry instances related to specified
Entry instance.
:param entry: the Entry instance.
:param live_only: flag to include only "live" entries.
:rtype: django.db.models.query.QuerySet.
"""
... | Returns queryset of Entry instances related to specified
Entry instance.
:param entry: the Entry instance.
:param live_only: flag to include only "live" entries.
:rtype: django.db.models.query.QuerySet. | entailment |
def chosen_view_factory(chooser_cls):
"""
Returns a ChosenView class that extends specified chooser class.
:param chooser_cls: the class to extend.
:rtype: class.
"""
class ChosenView(chooser_cls):
#noinspection PyUnusedLocal
def get(self, request, *args, **kwargs):
... | Returns a ChosenView class that extends specified chooser class.
:param chooser_cls: the class to extend.
:rtype: class. | entailment |
def form_invalid(self, form):
"""
Processes an invalid form submittal.
:param form: the form instance.
:rtype: django.http.HttpResponse.
"""
context = self.get_context_data(form=form)
#noinspection PyUnresolvedReferences
return render_modal_workflow(
... | Processes an invalid form submittal.
:param form: the form instance.
:rtype: django.http.HttpResponse. | entailment |
def form_valid(self, form):
"""
Processes a valid form submittal.
:param form: the form instance.
:rtype: django.http.HttpResponse.
"""
#noinspection PyAttributeOutsideInit
self.object = form.save()
# Index the link.
for backend in get_search_bac... | Processes a valid form submittal.
:param form: the form instance.
:rtype: django.http.HttpResponse. | entailment |
def get(self, request, *args, **kwargs):
"""
Returns GET response.
:param request: the request instance.
:rtype: django.http.HttpResponse.
"""
#noinspection PyAttributeOutsideInit
self.object_list = self.get_queryset()
context = self.get_co... | Returns GET response.
:param request: the request instance.
:rtype: django.http.HttpResponse. | entailment |
def get_form_kwargs(self):
"""
Returns the keyword arguments for instantiating the form.
:rtype: dict.
"""
kwargs = {
'initial': self.get_initial(),
'prefix': self.get_prefix(),
}
#noinspection PyUnresolvedReferences
if self.re... | Returns the keyword arguments for instantiating the form.
:rtype: dict. | entailment |
def create_entry_tag(sender, instance, created, **kwargs):
"""
Creates EntryTag for Entry corresponding to specified
ItemBase instance.
:param sender: the sending ItemBase class.
:param instance: the ItemBase instance.
"""
from ..models import (
Entry,
EntryTag
)
en... | Creates EntryTag for Entry corresponding to specified
ItemBase instance.
:param sender: the sending ItemBase class.
:param instance: the ItemBase instance. | entailment |
def delete_entry_tag(sender, instance, **kwargs):
"""
Deletes EntryTag for Entry corresponding to specified
TaggedItemBase instance.
:param sender: the sending TaggedItemBase class.
:param instance: the TaggedItemBase instance.
"""
from ..models import (
Entry,
EntryTag
... | Deletes EntryTag for Entry corresponding to specified
TaggedItemBase instance.
:param sender: the sending TaggedItemBase class.
:param instance: the TaggedItemBase instance. | entailment |
def delete_entry(sender, instance, **kwargs):
"""
Deletes Entry instance corresponding to specified instance.
:param sender: the sending class.
:param instance: the instance being deleted.
"""
from ..models import Entry
Entry.objects.get_for_model(instance)[0].delete() | Deletes Entry instance corresponding to specified instance.
:param sender: the sending class.
:param instance: the instance being deleted. | entailment |
def update_entry_attributes(sender, instance, **kwargs):
"""
Updates attributes for Entry instance corresponding to
specified instance.
:param sender: the sending class.
:param instance: the instance being saved.
"""
from ..models import Entry
entry = Entry.objects.get_for_model(instan... | Updates attributes for Entry instance corresponding to
specified instance.
:param sender: the sending class.
:param instance: the instance being saved. | entailment |
def get_revisions(page, page_num=1):
"""
Returns paginated queryset of PageRevision instances for
specified Page instance.
:param page: the page instance.
:param page_num: the pagination page number.
:rtype: django.db.models.query.QuerySet.
"""
revisions = page.revisions.order_by('-cr... | Returns paginated queryset of PageRevision instances for
specified Page instance.
:param page: the page instance.
:param page_num: the pagination page number.
:rtype: django.db.models.query.QuerySet. | entailment |
def page_revisions(request, page_id, template_name='wagtailrollbacks/edit_handlers/revisions.html'):
"""
Returns GET response for specified page revisions.
:param request: the request instance.
:param page_id: the page ID.
:param template_name: the template name.
:rtype: django.http.HttpRespons... | Returns GET response for specified page revisions.
:param request: the request instance.
:param page_id: the page ID.
:param template_name: the template name.
:rtype: django.http.HttpResponse. | entailment |
def preview_page_version(request, revision_id):
"""
Returns GET response for specified page preview.
:param request: the request instance.
:param reversion_pk: the page revision ID.
:rtype: django.http.HttpResponse.
"""
revision = get_object_or_404(PageRevision, pk=revision_id)
if not ... | Returns GET response for specified page preview.
:param request: the request instance.
:param reversion_pk: the page revision ID.
:rtype: django.http.HttpResponse. | entailment |
def confirm_page_reversion(request, revision_id, template_name='wagtailrollbacks/pages/confirm_reversion.html'):
"""
Handles page reversion process (GET and POST).
:param request: the request instance.
:param revision_id: the page revision ID.
:param template_name: the template name.
:rtype: dj... | Handles page reversion process (GET and POST).
:param request: the request instance.
:param revision_id: the page revision ID.
:param template_name: the template name.
:rtype: django.http.HttpResponse. | entailment |
def get_password(self, service, username):
"""Get password of the username for the service
"""
result = self._get_entry(self._keyring, service, username)
if result:
result = self._decrypt(result)
return result | Get password of the username for the service | entailment |
def set_password(self, service, username, password):
"""Set password for the username of the service
"""
password = self._encrypt(password or '')
keyring_working_copy = copy.deepcopy(self._keyring)
service_entries = keyring_working_copy.get(service)
if not service_entries... | Set password for the username of the service | entailment |
def _save_keyring(self, keyring_dict):
"""Helper to actually write the keyring to Google"""
import gdata
result = self.OK
file_contents = base64.urlsafe_b64encode(pickle.dumps(keyring_dict))
try:
if self.docs_entry:
extra_headers = {'Content-Type': 'te... | Helper to actually write the keyring to Google | entailment |
def calculate_token(self, text, seed=None):
""" Calculate the request token (`tk`) of a string
:param text: str The text to calculate a token for
:param seed: str The seed to use. By default this is the number of hours since epoch
"""
if seed is None:
seed = self._ge... | Calculate the request token (`tk`) of a string
:param text: str The text to calculate a token for
:param seed: str The seed to use. By default this is the number of hours since epoch | entailment |
def _request(method, url, session=None, **kwargs):
"""Make HTTP request, raising an exception if it fails.
"""
url = BASE_URL + url
if session:
request_func = getattr(session, method)
else:
request_func = getattr(requests, method)
response = request_func(url, **kwargs)
# rai... | Make HTTP request, raising an exception if it fails. | entailment |
def _send_dweet(payload, url, params=None, session=None):
"""Send a dweet to dweet.io
"""
data = json.dumps(payload)
headers = {'Content-type': 'application/json'}
return _request('post', url, data=data, headers=headers, params=params, session=session) | Send a dweet to dweet.io | entailment |
def dweet_for(thing_name, payload, key=None, session=None):
"""Send a dweet to dweet.io for a thing with a known name
"""
if key is not None:
params = {'key': key}
else:
params = None
return _send_dweet(payload, '/dweet/for/{0}'.format(thing_name), params=params, session=session) | Send a dweet to dweet.io for a thing with a known name | entailment |
def get_dweets_for(thing_name, key=None, session=None):
"""Read all the dweets for a dweeter
"""
if key is not None:
params = {'key': key}
else:
params = None
return _request('get', '/get/dweets/for/{0}'.format(thing_name), params=params, session=None) | Read all the dweets for a dweeter | entailment |
def remove_lock(lock, key, session=None):
"""Remove a lock (no matter what it's connected to).
"""
return _request('get', '/remove/lock/{0}'.format(lock), params={'key': key}, session=session) | Remove a lock (no matter what it's connected to). | entailment |
def lock(thing_name, lock, key, session=None):
"""Lock a thing (prevents unauthed dweets for the locked thing)
"""
return _request('get', '/lock/{0}'.format(thing_name), params={'key': key, 'lock': lock}, session=session) | Lock a thing (prevents unauthed dweets for the locked thing) | entailment |
def unlock(thing_name, key, session=None):
"""Unlock a thing
"""
return _request('get', '/unlock/{0}'.format(thing_name), params={'key': key}, session=session) | Unlock a thing | entailment |
def set_alert(thing_name, who, condition, key, session=None):
"""Set an alert on a thing with the given condition
"""
return _request('get', '/alert/{0}/when/{1}/{2}'.format(
','.join(who),
thing_name,
quote(condition),
), params={'key': key}, session=session) | Set an alert on a thing with the given condition | entailment |
def get_alert(thing_name, key, session=None):
"""Set an alert on a thing with the given condition
"""
return _request('get', '/get/alert/for/{0}'.format(thing_name), params={'key': key}, session=session) | Set an alert on a thing with the given condition | entailment |
def remove_alert(thing_name, key, session=None):
"""Remove an alert for the given thing
"""
return _request('get', '/remove/alert/for/{0}'.format(thing_name), params={'key': key}, session=session) | Remove an alert for the given thing | entailment |
def get_product_sets(self):
"""
list all product sets for current user
"""
# ensure we are using api url without a specific product set id
api_url = super(ProductSetAPI, self).base_url
return self.client.get(api_url) | list all product sets for current user | entailment |
def delete_all_product_sets(self):
"""
BE NOTICED: this will delete all product sets for current user
"""
# ensure we are using api url without a specific product set id
api_url = super(ProductSetAPI, self).base_url
return self.client.delete(api_url) | BE NOTICED: this will delete all product sets for current user | entailment |
def get_products(self, product_ids):
"""
This function (and backend API) is being obsoleted. Don't use it anymore.
"""
if self.product_set_id is None:
raise ValueError('product_set_id must be specified')
data = {'ids': product_ids}
return self.client.get(self.... | This function (and backend API) is being obsoleted. Don't use it anymore. | entailment |
def _check_stream_timeout(started, timeout):
"""Check if the timeout has been reached and raise a `StopIteration` if so.
"""
if timeout:
elapsed = datetime.datetime.utcnow() - started
if elapsed.seconds > timeout:
raise StopIteration | Check if the timeout has been reached and raise a `StopIteration` if so. | entailment |
def _listen_for_dweets_from_response(response):
"""Yields dweets as received from dweet.io's streaming API
"""
streambuffer = ''
for byte in response.iter_content():
if byte:
streambuffer += byte.decode('ascii')
try:
dweet = json.loads(streambuffer.splitli... | Yields dweets as received from dweet.io's streaming API | entailment |
def listen_for_dweets_from(thing_name, timeout=900, key=None, session=None):
"""Create a real-time subscription to dweets
"""
url = BASE_URL + '/listen/for/dweets/from/{0}'.format(thing_name)
session = session or requests.Session()
if key is not None:
params = {'key': key}
else:
... | Create a real-time subscription to dweets | entailment |
def add(self, service_id, request_id, description=None, details=None):
if not service_id:
raise ValueError('service_id is required')
if not request_id:
raise ValueError('request_id is required')
"""
curl -X POST \
-H 'x-ca-version: 1.0' \
... | curl -X POST \
-H 'x-ca-version: 1.0' \
-H 'x-ca-accesskeyid: YourAccessId' \
-d "service_id=p4dkh2sg&request_id=c13ed5aa-d6d2-11e8-ba11-02420a582a05&description=blahlblah" \
https://api.productai.cn/bad_cases/_0000204 | entailment |
def build(self, parallel=True, debug=False, force=False,
machine_readable=False):
"""Executes a `packer build`
:param bool parallel: Run builders in parallel
:param bool debug: Run in debug mode
:param bool force: Force artifact output even if exists
:param bool ma... | Executes a `packer build`
:param bool parallel: Run builders in parallel
:param bool debug: Run in debug mode
:param bool force: Force artifact output even if exists
:param bool machine_readable: Make output machine-readable | entailment |
def fix(self, to_file=None):
"""Implements the `packer fix` function
:param string to_file: File to output fixed template to
"""
self.packer_cmd = self.packer.fix
self._add_opt(self.packerfile)
result = self.packer_cmd()
if to_file:
with open(to_fil... | Implements the `packer fix` function
:param string to_file: File to output fixed template to | entailment |
def inspect(self, mrf=True):
"""Inspects a Packer Templates file (`packer inspect -machine-readable`)
To return the output in a readable form, the `-machine-readable` flag
is appended automatically, afterwhich the output is parsed and returned
as a dict of the following format:
... | Inspects a Packer Templates file (`packer inspect -machine-readable`)
To return the output in a readable form, the `-machine-readable` flag
is appended automatically, afterwhich the output is parsed and returned
as a dict of the following format:
"variables": [
{
... | entailment |
def push(self, create=True, token=False):
"""Implmenets the `packer push` function
UNTESTED! Must be used alongside an Atlas account
"""
self.packer_cmd = self.packer.push
self._add_opt('-create=true' if create else None)
self._add_opt('-tokn={0}'.format(token) if token... | Implmenets the `packer push` function
UNTESTED! Must be used alongside an Atlas account | entailment |
def validate(self, syntax_only=False):
"""Validates a Packer Template file (`packer validate`)
If the validation failed, an `sh` exception will be raised.
:param bool syntax_only: Whether to validate the syntax only
without validating the configuration itself.
"""
self.p... | Validates a Packer Template file (`packer validate`)
If the validation failed, an `sh` exception will be raised.
:param bool syntax_only: Whether to validate the syntax only
without validating the configuration itself. | entailment |
def _append_base_arguments(self):
"""Appends base arguments to packer commands.
-except, -only, -var and -var-file are appeneded to almost
all subcommands in packer. As such this can be called to add
these flags to the subcommand.
"""
if self.exc and self.only:
... | Appends base arguments to packer commands.
-except, -only, -var and -var-file are appeneded to almost
all subcommands in packer. As such this can be called to add
these flags to the subcommand. | entailment |
def _parse_inspection_output(self, output):
"""Parses the machine-readable output `packer inspect` provides.
See the inspect method for more info.
This has been tested vs. Packer v0.7.5
"""
parts = {'variables': [], 'builders': [], 'provisioners': []}
for line in output.... | Parses the machine-readable output `packer inspect` provides.
See the inspect method for more info.
This has been tested vs. Packer v0.7.5 | entailment |
def post(self, url, data, headers=None):
"""
Perform an HTTP POST request for a given url.
Returns the response object.
"""
return self._request('POST', url, data, headers=headers) | Perform an HTTP POST request for a given url.
Returns the response object. | entailment |
def put(self, url, data, headers=None):
"""
Perform an HTTP PUT request for a given url.
Returns the response object.
"""
return self._request('PUT', url, data, headers=headers) | Perform an HTTP PUT request for a given url.
Returns the response object. | entailment |
def query(self, *args):
"""
Query a fulltext index by key and query or just a plain Lucene query,
i1 = gdb.nodes.indexes.get('people',type='fulltext', provider='lucene')
i1.query('name','do*')
i1.query('name:do*')
In this example, the last two line are equivalent.
... | Query a fulltext index by key and query or just a plain Lucene query,
i1 = gdb.nodes.indexes.get('people',type='fulltext', provider='lucene')
i1.query('name','do*')
i1.query('name:do*')
In this example, the last two line are equivalent. | entailment |
def _plot_graph(self, graph, title=None, width=None, height=None):
"""
Return a HTML representation for a particular QuerySequence.
Mainly for IPython Notebook.
"""
if not self._elements_row and not self._elements_graph:
raise ValueError('Unable to display the graph o... | Return a HTML representation for a particular QuerySequence.
Mainly for IPython Notebook. | entailment |
def do_call(self, path, method, body=None, headers=None):
"""
Send an HTTP request to the REST API.
:param string path: A URL
:param string method: The HTTP method (GET, POST, etc.) to use
in the request.
:param string body: A string representing any data to be sent ... | Send an HTTP request to the REST API.
:param string path: A URL
:param string method: The HTTP method (GET, POST, etc.) to use
in the request.
:param string body: A string representing any data to be sent in the
body of the HTTP request.
:param dictionary headers... | entailment |
def _call(self, path, method, body=None, headers=None):
"""
Wrapper around http.do_call that transforms some HTTPError into
our own exceptions
"""
try:
resp = self.http.do_call(path, method, body, headers)
except http.HTTPError as err:
if err.statu... | Wrapper around http.do_call that transforms some HTTPError into
our own exceptions | entailment |
def is_alive(self, vhost='%2F'):
"""
Uses the aliveness-test API call to determine if the
server is alive and the vhost is active. The broker (not this code)
creates a queue and then sends/consumes a message from it.
:param string vhost: There should be no real reason to ever ch... | Uses the aliveness-test API call to determine if the
server is alive and the vhost is active. The broker (not this code)
creates a queue and then sends/consumes a message from it.
:param string vhost: There should be no real reason to ever change
this from the default value, but it'... | entailment |
def get_whoami(self):
"""
A convenience function used in the event that you need to confirm that
the broker thinks you are who you think you are.
:returns dict whoami: Dict structure contains:
* administrator: whether the user is has admin privileges
* name: user... | A convenience function used in the event that you need to confirm that
the broker thinks you are who you think you are.
:returns dict whoami: Dict structure contains:
* administrator: whether the user is has admin privileges
* name: user name
* auth_backend: backend ... | entailment |
def get_vhost_names(self):
"""
A convenience function for getting back only the vhost names instead of
the larger vhost dicts.
:returns list vhost_names: A list of just the vhost names.
"""
vhosts = self.get_all_vhosts()
vhost_names = [i['name'] for i in vhosts]
... | A convenience function for getting back only the vhost names instead of
the larger vhost dicts.
:returns list vhost_names: A list of just the vhost names. | entailment |
def get_vhost(self, vname):
"""
Returns the attributes of a single named vhost in a dict.
:param string vname: Name of the vhost to get.
:returns dict vhost: Attribute dict for the named vhost
"""
vname = quote(vname, '')
path = Client.urls['vhosts_by_name'] % ... | Returns the attributes of a single named vhost in a dict.
:param string vname: Name of the vhost to get.
:returns dict vhost: Attribute dict for the named vhost | entailment |
def create_vhost(self, vname):
"""
Creates a vhost on the server to house exchanges.
:param string vname: The name to give to the vhost on the server
:returns: boolean
"""
vname = quote(vname, '')
path = Client.urls['vhosts_by_name'] % vname
return self._... | Creates a vhost on the server to house exchanges.
:param string vname: The name to give to the vhost on the server
:returns: boolean | entailment |
def delete_vhost(self, vname):
"""
Deletes a vhost from the server. Note that this also deletes any
exchanges or queues that belong to this vhost.
:param string vname: Name of the vhost to delete from the server.
"""
vname = quote(vname, '')
path = Client.urls['v... | Deletes a vhost from the server. Note that this also deletes any
exchanges or queues that belong to this vhost.
:param string vname: Name of the vhost to delete from the server. | entailment |
def get_permissions(self):
"""
:returns: list of dicts, or an empty list if there are no permissions.
"""
path = Client.urls['all_permissions']
conns = self._call(path, 'GET')
return conns | :returns: list of dicts, or an empty list if there are no permissions. | entailment |
def get_vhost_permissions(self, vname):
"""
:returns: list of dicts, or an empty list if there are no permissions.
:param string vname: Name of the vhost to set perms on.
"""
vname = quote(vname, '')
path = Client.urls['vhost_permissions_get'] % (vname,)
conns = ... | :returns: list of dicts, or an empty list if there are no permissions.
:param string vname: Name of the vhost to set perms on. | entailment |
def get_user_permissions(self, username):
"""
:returns: list of dicts, or an empty list if there are no permissions.
:param string username: User to set permissions for.
"""
path = Client.urls['user_permissions'] % (username,)
conns = self._call(path, 'GET')
ret... | :returns: list of dicts, or an empty list if there are no permissions.
:param string username: User to set permissions for. | entailment |
def set_vhost_permissions(self, vname, username, config, rd, wr):
"""
Set permissions for a given username on a given vhost. Both
must already exist.
:param string vname: Name of the vhost to set perms on.
:param string username: User to set permissions for.
:param strin... | Set permissions for a given username on a given vhost. Both
must already exist.
:param string vname: Name of the vhost to set perms on.
:param string username: User to set permissions for.
:param string config: Permission pattern for configuration operations
for this user in... | entailment |
def delete_permission(self, vname, username):
"""
Delete permission for a given username on a given vhost. Both
must already exist.
:param string vname: Name of the vhost to set perms on.
:param string username: User to set permissions for.
"""
vname = quote(vnam... | Delete permission for a given username on a given vhost. Both
must already exist.
:param string vname: Name of the vhost to set perms on.
:param string username: User to set permissions for. | entailment |
def get_exchanges(self, vhost=None):
"""
:returns: A list of dicts
:param string vhost: A vhost to query for exchanges, or None (default),
which triggers a query for all exchanges in all vhosts.
"""
if vhost:
vhost = quote(vhost, '')
path = Cl... | :returns: A list of dicts
:param string vhost: A vhost to query for exchanges, or None (default),
which triggers a query for all exchanges in all vhosts. | entailment |
def get_exchange(self, vhost, name):
"""
Gets a single exchange which requires a vhost and name.
:param string vhost: The vhost containing the target exchange
:param string name: The name of the exchange
:returns: dict
"""
vhost = quote(vhost, '')
name =... | Gets a single exchange which requires a vhost and name.
:param string vhost: The vhost containing the target exchange
:param string name: The name of the exchange
:returns: dict | entailment |
def create_exchange(self,
vhost,
name,
xtype,
auto_delete=False,
durable=True,
internal=False,
arguments=None):
"""
Creates an exchange ... | Creates an exchange in the given vhost with the given name. As per the
RabbitMQ API documentation, a JSON body also needs to be included that
"looks something like this":
{"type":"direct",
"auto_delete":false,
"durable":true,
"internal":false,
"arguments":[]}
... | entailment |
def publish(self, vhost, xname, rt_key, payload, payload_enc='string',
properties=None):
"""
Publish a message to an exchange.
:param string vhost: vhost housing the target exchange
:param string xname: name of the target exchange
:param string rt_key: routing ke... | Publish a message to an exchange.
:param string vhost: vhost housing the target exchange
:param string xname: name of the target exchange
:param string rt_key: routing key for message
:param string payload: the message body for publishing
:param string payload_enc: encoding of t... | entailment |
def delete_exchange(self, vhost, name):
"""
Delete the named exchange from the named vhost. The API returns a 204
on success, in which case this method returns True, otherwise the
error is raised.
:param string vhost: Vhost where target exchange was created
:param string... | Delete the named exchange from the named vhost. The API returns a 204
on success, in which case this method returns True, otherwise the
error is raised.
:param string vhost: Vhost where target exchange was created
:param string name: The name of the exchange to delete.
:returns ... | entailment |
def get_queues(self, vhost=None):
"""
Get all queues, or all queues in a vhost if vhost is not None.
Returns a list.
:param string vhost: The virtual host to list queues for. If This is
None (the default), all queues for the broker instance
are re... | Get all queues, or all queues in a vhost if vhost is not None.
Returns a list.
:param string vhost: The virtual host to list queues for. If This is
None (the default), all queues for the broker instance
are returned.
:returns: A list of dicts, each repres... | entailment |
def get_queue(self, vhost, name):
"""
Get a single queue, which requires both vhost and name.
:param string vhost: The virtual host for the queue being requested.
If the vhost is '/', note that it will be translated to '%2F' to
conform to URL encoding requirements.
... | Get a single queue, which requires both vhost and name.
:param string vhost: The virtual host for the queue being requested.
If the vhost is '/', note that it will be translated to '%2F' to
conform to URL encoding requirements.
:param string name: The name of the queue being req... | entailment |
def get_queue_depth(self, vhost, name):
"""
Get the number of messages currently in a queue. This is a convenience
function that just calls :meth:`Client.get_queue` and pulls
out/returns the 'messages' field from the dictionary it returns.
:param string vhost: The vhost of the... | Get the number of messages currently in a queue. This is a convenience
function that just calls :meth:`Client.get_queue` and pulls
out/returns the 'messages' field from the dictionary it returns.
:param string vhost: The vhost of the queue being queried.
:param string name: The name o... | entailment |
def get_queue_depths(self, vhost, names=None):
"""
Get the number of messages currently sitting in either the queue
names listed in 'names', or all queues in 'vhost' if no 'names' are
given.
:param str vhost: Vhost where queues in 'names' live.
:param list names: OPTIONA... | Get the number of messages currently sitting in either the queue
names listed in 'names', or all queues in 'vhost' if no 'names' are
given.
:param str vhost: Vhost where queues in 'names' live.
:param list names: OPTIONAL - Specific queues to show depths for. If
None, sh... | entailment |
def purge_queues(self, queues):
"""
Purge all messages from one or more queues.
:param list queues: A list of ('qname', 'vhost') tuples.
:returns: True on success
"""
for name, vhost in queues:
vhost = quote(vhost, '')
name = quote(name, '')
... | Purge all messages from one or more queues.
:param list queues: A list of ('qname', 'vhost') tuples.
:returns: True on success | entailment |
def purge_queue(self, vhost, name):
"""
Purge all messages from a single queue. This is a convenience method
so you aren't forced to supply a list containing a single tuple to
the purge_queues method.
:param string vhost: The vhost of the queue being purged.
:param strin... | Purge all messages from a single queue. This is a convenience method
so you aren't forced to supply a list containing a single tuple to
the purge_queues method.
:param string vhost: The vhost of the queue being purged.
:param string name: The name of the queue being purged.
:rty... | entailment |
def create_queue(self, vhost, name, **kwargs):
"""
Create a queue. The API documentation specifies that all of the body
elements are optional, so this method only requires arguments needed
to form the URI
:param string vhost: The vhost to create the queue in.
:param stri... | Create a queue. The API documentation specifies that all of the body
elements are optional, so this method only requires arguments needed
to form the URI
:param string vhost: The vhost to create the queue in.
:param string name: The name of the queue
More on these operations ca... | entailment |
def delete_queue(self, vhost, qname):
"""
Deletes the named queue from the named vhost.
:param string vhost: Vhost housing the queue to be deleted.
:param string qname: Name of the queue to delete.
Note that if you just want to delete the messages from a queue, you
shou... | Deletes the named queue from the named vhost.
:param string vhost: Vhost housing the queue to be deleted.
:param string qname: Name of the queue to delete.
Note that if you just want to delete the messages from a queue, you
should use purge_queue instead of deleting/recreating a queue. | entailment |
def get_messages(self, vhost, qname, count=1,
requeue=False, truncate=None, encoding='auto'):
"""
Gets <count> messages from the queue.
:param string vhost: Name of vhost containing the queue
:param string qname: Name of the queue to consume from
:param int ... | Gets <count> messages from the queue.
:param string vhost: Name of vhost containing the queue
:param string qname: Name of the queue to consume from
:param int count: Number of messages to get.
:param bool requeue: Whether to requeue the message after getting it.
This will c... | entailment |
def get_connections(self):
"""
:returns: list of dicts, or an empty list if there are no connections.
"""
path = Client.urls['all_connections']
conns = self._call(path, 'GET')
return conns | :returns: list of dicts, or an empty list if there are no connections. | entailment |
def get_connection(self, name):
"""
Get a connection by name. To get the names, use get_connections.
:param string name: Name of connection to get
:returns dict conn: A connection attribute dictionary.
"""
name = quote(name, '')
path = Client.urls['connections_b... | Get a connection by name. To get the names, use get_connections.
:param string name: Name of connection to get
:returns dict conn: A connection attribute dictionary. | entailment |
def delete_connection(self, name):
"""
Close the named connection. The API returns a 204 on success,
in which case this method returns True, otherwise the
error is raised.
:param string name: The name of the connection to delete.
:returns bool: True on success.
"... | Close the named connection. The API returns a 204 on success,
in which case this method returns True, otherwise the
error is raised.
:param string name: The name of the connection to delete.
:returns bool: True on success. | entailment |
def get_channels(self):
"""
Return a list of dicts containing details about broker connections.
:returns: list of dicts
"""
path = Client.urls['all_channels']
chans = self._call(path, 'GET')
return chans | Return a list of dicts containing details about broker connections.
:returns: list of dicts | entailment |
def get_channel(self, name):
"""
Get a channel by name. To get the names, use get_channels.
:param string name: Name of channel to get
:returns dict conn: A channel attribute dictionary.
"""
name = quote(name, '')
path = Client.urls['channels_by_name'] % name
... | Get a channel by name. To get the names, use get_channels.
:param string name: Name of channel to get
:returns dict conn: A channel attribute dictionary. | entailment |
def get_bindings(self):
"""
:returns: list of dicts
"""
path = Client.urls['all_bindings']
bindings = self._call(path, 'GET')
return bindings | :returns: list of dicts | entailment |
def get_queue_bindings(self, vhost, qname):
"""
Return a list of dicts, one dict per binding. The dict format coming
from RabbitMQ for queue named 'testq' is:
{"source":"sourceExch","vhost":"/","destination":"testq",
"destination_type":"queue","routing_key":"*.*","arguments":{}... | Return a list of dicts, one dict per binding. The dict format coming
from RabbitMQ for queue named 'testq' is:
{"source":"sourceExch","vhost":"/","destination":"testq",
"destination_type":"queue","routing_key":"*.*","arguments":{},
"properties_key":"%2A.%2A"} | entailment |
def create_binding(self, vhost, exchange, queue, rt_key=None, args=None):
"""
Creates a binding between an exchange and a queue on a given vhost.
:param string vhost: vhost housing the exchange/queue to bind
:param string exchange: the target exchange of the binding
:param strin... | Creates a binding between an exchange and a queue on a given vhost.
:param string vhost: vhost housing the exchange/queue to bind
:param string exchange: the target exchange of the binding
:param string queue: the queue to bind to the exchange
:param string rt_key: the routing key to us... | entailment |
def delete_binding(self, vhost, exchange, queue, rt_key):
"""
Deletes a binding between an exchange and a queue on a given vhost.
:param string vhost: vhost housing the exchange/queue to bind
:param string exchange: the target exchange of the binding
:param string queue: the que... | Deletes a binding between an exchange and a queue on a given vhost.
:param string vhost: vhost housing the exchange/queue to bind
:param string exchange: the target exchange of the binding
:param string queue: the queue to bind to the exchange
:param string rt_key: the routing key to us... | entailment |
def create_user(self, username, password, tags=""):
"""
Creates a user.
:param string username: The name to give to the new user
:param string password: Password for the new user
:param string tags: Comma-separated list of tags for the user
:returns: boolean
"""
... | Creates a user.
:param string username: The name to give to the new user
:param string password: Password for the new user
:param string tags: Comma-separated list of tags for the user
:returns: boolean | entailment |
def delete_user(self, username):
"""
Deletes a user from the server.
:param string username: Name of the user to delete from the server.
"""
path = Client.urls['users_by_name'] % username
return self._call(path, 'DELETE') | Deletes a user from the server.
:param string username: Name of the user to delete from the server. | entailment |
def index(request):
"""
Redirects to the default wiki index name.
"""
kwargs = {'slug': getattr(settings, 'WAKAWAKA_DEFAULT_INDEX', 'WikiIndex')}
redirect_to = reverse('wakawaka_page', kwargs=kwargs)
return HttpResponseRedirect(redirect_to) | Redirects to the default wiki index name. | entailment |
def page(
request,
slug,
rev_id=None,
template_name='wakawaka/page.html',
extra_context=None,
):
"""
Displays a wiki page. Redirects to the edit view if the page doesn't exist.
"""
try:
queryset = WikiPage.objects.all()
page = queryset.get(slug=slug)
rev = pag... | Displays a wiki page. Redirects to the edit view if the page doesn't exist. | entailment |
def edit(
request,
slug,
rev_id=None,
template_name='wakawaka/edit.html',
extra_context=None,
wiki_page_form=WikiPageForm,
wiki_delete_form=DeleteWikiPageForm,
):
"""
Displays the form for editing and deleting a page.
"""
# Get the page for slug and get a specific revision, i... | Displays the form for editing and deleting a page. | entailment |
def revisions(
request, slug, template_name='wakawaka/revisions.html', extra_context=None
):
"""
Displays the list of all revisions for a specific WikiPage
"""
queryset = WikiPage.objects.all()
page = get_object_or_404(queryset, slug=slug)
template_context = {'page': page}
template_cont... | Displays the list of all revisions for a specific WikiPage | entailment |
def changes(
request, slug, template_name='wakawaka/changes.html', extra_context=None
):
"""
Displays the changes between two revisions.
"""
rev_a_id = request.GET.get('a', None)
rev_b_id = request.GET.get('b', None)
# Some stinky fingers manipulated the url
if not rev_a_id or not rev_b... | Displays the changes between two revisions. | entailment |
def revision_list(
request, template_name='wakawaka/revision_list.html', extra_context=None
):
"""
Displays a list of all recent revisions.
"""
revision_list = Revision.objects.all()
template_context = {'revision_list': revision_list}
template_context.update(extra_context or {})
return r... | Displays a list of all recent revisions. | entailment |
def page_list(
request, template_name='wakawaka/page_list.html', extra_context=None
):
"""
Displays all Pages
"""
page_list = WikiPage.objects.all()
page_list = page_list.order_by('slug')
template_context = {
'page_list': page_list,
'index_slug': getattr(settings, 'WAKAWAKA_... | Displays all Pages | entailment |
def delete_wiki(self, request, page, rev):
"""
Deletes the page with all revisions or the revision, based on the
users choice.
Returns a HttpResponseRedirect.
"""
# Delete the page
if (
self.cleaned_data.get('delete') == 'page'
and reques... | Deletes the page with all revisions or the revision, based on the
users choice.
Returns a HttpResponseRedirect. | entailment |
def get_real_field(model, field_name):
'''
Get the real field from a model given its name.
Handle nested models recursively (aka. ``__`` lookups)
'''
parts = field_name.split('__')
field = model._meta.get_field(parts[0])
if len(parts) == 1:
return model._meta.get_field(field_name)
... | Get the real field from a model given its name.
Handle nested models recursively (aka. ``__`` lookups) | entailment |
def can_regex(self, field):
'''Test if a given field supports regex lookups'''
from django.conf import settings
if settings.DATABASES['default']['ENGINE'].endswith('sqlite3'):
return not isinstance(get_real_field(self.model, field), UNSUPPORTED_REGEX_FIELDS)
else:
... | Test if a given field supports regex lookups | entailment |
def get_orders(self):
'''Get ordering fields for ``QuerySet.order_by``'''
orders = []
iSortingCols = self.dt_data['iSortingCols']
dt_orders = [(self.dt_data['iSortCol_%s' % i], self.dt_data['sSortDir_%s' % i]) for i in xrange(iSortingCols)]
for field_idx, field_dir in dt_orders:
... | Get ordering fields for ``QuerySet.order_by`` | entailment |
def global_search(self, queryset):
'''Filter a queryset with global search'''
search = self.dt_data['sSearch']
if search:
if self.dt_data['bRegex']:
criterions = [
Q(**{'%s__iregex' % field: search})
for field in self.get_db_fie... | Filter a queryset with global search | entailment |
def column_search(self, queryset):
'''Filter a queryset with column search'''
for idx in xrange(self.dt_data['iColumns']):
search = self.dt_data['sSearch_%s' % idx]
if search:
if hasattr(self, 'search_col_%s' % idx):
custom_search = getattr(sel... | Filter a queryset with column search | entailment |
def get_queryset(self):
'''Apply Datatables sort and search criterion to QuerySet'''
qs = super(DatatablesView, self).get_queryset()
# Perform global search
qs = self.global_search(qs)
# Perform column search
qs = self.column_search(qs)
# Return the ordered querys... | Apply Datatables sort and search criterion to QuerySet | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.