INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Start a pyros node.: param interface: the interface implementation ( ROS Mock ZMP etc. ): param config: the config file path absolute or relative to working directory: param logfile: the logfile path absolute or relative to working directory: param ros_args: the ros arguments ( useful to absorb additional args when lau... | def run(interface, config, logfile, ros_args):
"""
Start a pyros node.
:param interface: the interface implementation (ROS, Mock, ZMP, etc.)
:param config: the config file path, absolute, or relative to working directory
:param logfile: the logfile path, absolute, or relative to working directory
... |
store nick user host in kwargs if prefix is correct format | def nickmask(prefix: str, kwargs: Dict[str, Any]) -> None:
""" store nick, user, host in kwargs if prefix is correct format """
if "!" in prefix and "@" in prefix:
# From a user
kwargs["nick"], remainder = prefix.split("!", 1)
kwargs["user"], kwargs["host"] = remainder.split("@", 1)
... |
Parse message according to rfc 2812 for routing | def split_line(msg: str) -> Tuple[str, str, List[str]]:
""" Parse message according to rfc 2812 for routing """
match = RE_IRCLINE.match(msg)
if not match:
raise ValueError("Invalid line")
prefix = match.group("prefix") or ""
command = match.group("command")
params = (match.group("param... |
Return present value ( default to field ) if field in kwargs and Truthy otherwise return missing value | def b(field: str, kwargs: Dict[str, Any],
present: Optional[Any] = None, missing: Any = '') -> str:
"""
Return `present` value (default to `field`) if `field` in `kwargs` and
Truthy, otherwise return `missing` value
"""
if kwargs.get(field):
return field if present is None else str(pre... |
Alias for more readable command construction | def f(field: str, kwargs: Dict[str, Any],
default: Optional[Any] = None) -> str:
""" Alias for more readable command construction """
if default is not None:
return str(kwargs.get(field, default))
return str(kwargs[field]) |
Util for joining multiple fields with commas | def pack(field: str, kwargs: Dict[str, Any],
default: Optional[Any] = None, sep: str=',') -> str:
""" Util for joining multiple fields with commas """
if default is not None:
value = kwargs.get(field, default)
else:
value = kwargs[field]
if isinstance(value, str):
return... |
Pack a command to send to an IRC server | def pack_command(command: str, **kwargs: Any) -> str:
""" Pack a command to send to an IRC server """
if not command:
raise ValueError("Must provide a command")
if not isinstance(command, str):
raise ValueError("Command must be a string")
command = command.upper()
# ================... |
Open a connection to the defined server. | async def connect(self) -> None:
"""Open a connection to the defined server."""
def protocol_factory() -> Protocol:
return Protocol(client=self)
_, protocol = await self.loop.create_connection(
protocol_factory,
host=self.host,
port=self.port,
... |
Trigger all handlers for an event to ( asynchronously ) execute | def trigger(self, event: str, **kwargs: Any) -> None:
"""Trigger all handlers for an event to (asynchronously) execute"""
event = event.upper()
for func in self._event_handlers[event]:
self.loop.create_task(func(**kwargs))
# This will unblock anyone that is awaiting on the ne... |
Decorate a function to be invoked when the given event occurs. | def on(self, event: str, func: Optional[Callable] = None) -> Callable:
"""
Decorate a function to be invoked when the given event occurs.
The function may be a coroutine. Your function should accept **kwargs
in case an event is triggered with unexpected kwargs.
Example
... |
Send a message to the server. | def send(self, command: str, **kwargs: Any) -> None:
"""
Send a message to the server.
.. code-block:: python
client.send("nick", nick="weatherbot")
client.send("privmsg", target="#python", message="Hello, World!")
"""
packed_command = pack_command(comm... |
client callback entrance | def _handle(self, nick, target, message, **kwargs):
""" client callback entrance """
for regex, (func, pattern) in self.routes.items():
match = regex.match(message)
if match:
self.client.loop.create_task(
func(nick, target, message, match, **kw... |
parse commandline arguments and print result | def main():
"""parse commandline arguments and print result"""
fcodes = collections.OrderedDict((
('f.i', protocol.FLG_FORMAT_FDI),
('fi', protocol.FLG_FORMAT_FI),
('f.i.c', protocol.FLG_FORMAT_FDIDC),
('f.ic', protocol.FLG_FORMAT_FDIC),
('fi.c', protocol.FLG_FORMAT_FIDC... |
parse commandline arguments and print result | def main():
"""parse commandline arguments and print result"""
#
# setup command line parsing a la argpase
#
parser = argparse.ArgumentParser()
# positional args
parser.add_argument('uri', metavar='URI', nargs='?', default='/',
help='[owserver:]//hostname:port/path'... |
Constructs the url for a cheddar API resource | def build_url(self, path, params=None):
'''
Constructs the url for a cheddar API resource
'''
url = u'%s/%s/productCode/%s' % (
self.endpoint,
path,
self.product_code,
)
if params:
for key, value in params.items():
... |
Makes a request to the cheddar api using the authentication and configuration settings available. | def make_request(self, path, params=None, data=None, method=None):
'''
Makes a request to the cheddar api using the authentication and
configuration settings available.
'''
# Setup values
url = self.build_url(path, params)
client_log.debug('Requesting: %s' % url)... |
parse commandline arguments and print result | def main():
"""parse commandline arguments and print result"""
#
# setup command line parsing a la argpase
#
parser = argparse.ArgumentParser()
# positional args
parser.add_argument('uri', metavar='URI', nargs='?', default='/',
help='[owserver:]//server:port/entity'... |
factory function that returns a proxy object for an owserver at host port. | def proxy(host='localhost', port=4304, flags=0, persistent=False,
verbose=False, ):
"""factory function that returns a proxy object for an owserver at
host, port.
"""
# resolve host name/port
try:
gai = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM,
... |
factory function for cloning a proxy object | def clone(proxy, persistent=True):
"""factory function for cloning a proxy object"""
if not isinstance(proxy, _Proxy):
raise TypeError('argument is not a Proxy object')
if persistent:
pclass = _PersistentProxy
else:
pclass = _Proxy
return pclass(proxy._family, proxy._socka... |
shutdown connection | def shutdown(self):
"""shutdown connection"""
if self.verbose:
print(self.socket.getsockname(), 'xx', self.peername)
try:
self.socket.shutdown(socket.SHUT_RDWR)
except IOError as err:
assert err.errno is _ENOTCONN, "unexpected IOError: %s" % err
... |
send message to server and return response | def req(self, msgtype, payload, flags, size=0, offset=0, timeout=0):
"""send message to server and return response"""
if timeout < 0:
raise ValueError("timeout cannot be negative!")
tohead = _ToServerHeader(payload=len(payload), type=msgtype,
flags=... |
send message to server | def _send_msg(self, header, payload):
"""send message to server"""
if self.verbose:
print('->', repr(header))
print('..', repr(payload))
assert header.payload == len(payload)
try:
sent = self.socket.send(header + payload)
except IOError as err... |
read message from server | def _read_msg(self):
"""read message from server"""
#
# NOTE:
# '_recv_socket(nbytes)' was implemented as
# 'socket.recv(nbytes, socket.MSG_WAITALL)'
# but socket.MSG_WAITALL proved not reliable
#
def _recv_socket(nbytes):
"""read nbytes byte... |
retcode data = sendmess ( msgtype payload ) send generic message and returns retcode data | def sendmess(self, msgtype, payload, flags=0, size=0, offset=0, timeout=0):
""" retcode, data = sendmess(msgtype, payload)
send generic message and returns retcode, data
"""
flags |= self.flags
assert not (flags & FLG_PERSISTENCE)
with self._new_connection() as conn:
... |
sends a NOP packet and waits response ; returns None | def ping(self):
"""sends a NOP packet and waits response; returns None"""
ret, data = self.sendmess(MSG_NOP, bytes())
if data or ret > 0:
raise ProtocolError('invalid reply to ping message')
if ret < 0:
raise OwnetError(-ret, self.errmess[-ret]) |
returns True if there is an entity at path | def present(self, path, timeout=0):
"""returns True if there is an entity at path"""
ret, data = self.sendmess(MSG_PRESENCE, str2bytez(path),
timeout=timeout)
assert ret <= 0 and not data, (ret, data)
if ret < 0:
return False
else:
... |
list entities at path | def dir(self, path='/', slash=True, bus=False, timeout=0):
"""list entities at path"""
if slash:
msg = MSG_DIRALLSLASH
else:
msg = MSG_DIRALL
if bus:
flags = self.flags | FLG_BUS_RET
else:
flags = self.flags & ~FLG_BUS_RET
... |
read data at path | def read(self, path, size=MAX_PAYLOAD, offset=0, timeout=0):
"""read data at path"""
if size > MAX_PAYLOAD:
raise ValueError("size cannot exceed %d" % MAX_PAYLOAD)
ret, data = self.sendmess(MSG_READ, str2bytez(path),
size=size, offset=offset, timeo... |
write data at path | def write(self, path, data, offset=0, timeout=0):
"""write data at path
path is a string, data binary; it is responsability of the caller
ensure proper encoding.
"""
# fixme: check of path type delayed to str2bytez
if not isinstance(data, (bytes, bytearray, )):
... |
retcode data = sendmess ( msgtype payload ) send generic message and returns retcode data | def sendmess(self, msgtype, payload, flags=0, size=0, offset=0, timeout=0):
"""
retcode, data = sendmess(msgtype, payload)
send generic message and returns retcode, data
"""
# reuse last valid connection or create new
conn = self.conn or self._new_connection()
# ... |
Returns all customers. Sometimes they are too much and cause internal server errors on CG. API call permits post parameters for filtering which tends to fix this https:// cheddargetter. com/ developers#all - customers | def get_customers(self, filter_data=None):
'''
Returns all customers. Sometimes they are too much and cause internal
server errors on CG. API call permits post parameters for filtering
which tends to fix this
https://cheddargetter.com/developers#all-customers
filter_da... |
This method does exactly what you think it does. Calling this method deletes all customer data in your cheddar product and the configured gateway. This action cannot be undone. DO NOT RUN THIS UNLESS YOU REALLY REALLY REALLY MEAN TO! | def delete_all_customers(self):
'''
This method does exactly what you think it does. Calling this method
deletes all customer data in your cheddar product and the configured
gateway. This action cannot be undone.
DO NOT RUN THIS UNLESS YOU REALLY, REALLY, REALLY MEAN T... |
An estimated initial bill date for an account created today based on available plan info. | def initial_bill_date(self):
'''
An estimated initial bill date for an account created today,
based on available plan info.
'''
time_to_start = None
if self.initial_bill_count_unit == 'months':
time_to_start = relativedelta(months=self.initial_bill_co... |
Add an arbitrary charge or credit to a customer s account. A positive number will create a charge. A negative number will create a credit. each_amount is normalized to a Decimal with a precision of 2 as that is the level of precision which the cheddar API supports. | def charge(self, code, each_amount, quantity=1, description=None):
'''
Add an arbitrary charge or credit to a customer's account. A positive
number will create a charge. A negative number will create a credit.
each_amount is normalized to a Decimal with a precision of 2 as tha... |
Charges should be a list of charges to execute immediately. Each value in the charges diectionary should be a dictionary with the following keys: | def create_one_time_invoice(self, charges):
'''
Charges should be a list of charges to execute immediately. Each
value in the charges diectionary should be a dictionary with the
following keys:
code
Your code for this charge. This code will be displayed in the
... |
Set the item s quantity to the passed in amount. If nothing is passed in a quantity of 1 is assumed. If a decimal value is passsed in it is rounded to the 4th decimal place as that is the level of precision which the Cheddar API accepts. | def set(self, quantity):
'''
Set the item's quantity to the passed in amount. If nothing is
passed in, a quantity of 1 is assumed. If a decimal value is passsed
in, it is rounded to the 4th decimal place as that is the level of
precision which the Cheddar API accepts.
... |
Compares each field of the name one at a time to see if they match. Each name field has context - specific comparison logic. | def deep_compare(self, other, settings):
"""
Compares each field of the name one at a time to see if they match.
Each name field has context-specific comparison logic.
:param Name other: other Name for comparison
:return bool: whether the two names are compatible
"""
... |
Compares each field of the name one at a time to see if they match. Each name field has context - specific comparison logic. | def ratio_deep_compare(self, other, settings):
"""
Compares each field of the name one at a time to see if they match.
Each name field has context-specific comparison logic.
:param Name other: other Name for comparison
:return int: sequence ratio match (out of 100)
"""
... |
Return True if names are not incompatible. | def _is_compatible_with(self, other):
"""
Return True if names are not incompatible.
This checks that the gender of titles and compatibility of suffixes
"""
title = self._compare_title(other)
suffix = self._compare_suffix(other)
return title and suffix |
Return False if titles have different gender associations | def _compare_title(self, other):
"""Return False if titles have different gender associations"""
# If title is omitted, assume a match
if not self.title or not other.title:
return True
titles = set(self.title_list + other.title_list)
return not (titles & MALE_TITLE... |
Return false if suffixes are mutually exclusive | def _compare_suffix(self, other):
"""Return false if suffixes are mutually exclusive"""
# If suffix is omitted, assume a match
if not self.suffix or not other.suffix:
return True
# Check if more than one unique suffix
suffix_set = set(self.suffix_list + other.suffix... |
Return comparison of first middle and last components | def _compare_components(self, other, settings, ratio=False):
"""Return comparison of first, middle, and last components"""
first = compare_name_component(
self.first_list,
other.first_list,
settings['first'],
ratio,
)
if settings['check_n... |
Return weights of name components based on whether or not they were omitted | def _determine_weights(self, other, settings):
"""
Return weights of name components based on whether or not they were
omitted
"""
# TODO: Reduce weight for matches by prefix or initials
first_is_used = settings['first']['required'] or \
self.first and other... |
: param app:: class: sanic. Sanic instance to rate limit. | def init_app(self, app):
"""
:param app: :class:`sanic.Sanic` instance to rate limit.
"""
self.enabled = app.config.setdefault(C.ENABLED, True)
self._swallow_errors = app.config.setdefault(
C.SWALLOW_ERRORS, self._swallow_errors
)
self._storage_options... |
decorator to be used for rate limiting individual routes. | def limit(self, limit_value, key_func=None, per_method=False,
methods=None, error_message=None, exempt_when=None):
"""
decorator to be used for rate limiting individual routes.
:param limit_value: rate limit string or a callable that returns a string.
:ref:`ratelimit-stri... |
decorator to be applied to multiple routes sharing the same rate limit. | def shared_limit(self, limit_value, scope, key_func=None,
error_message=None, exempt_when=None):
"""
decorator to be applied to multiple routes sharing the same rate limit.
:param limit_value: rate limit string or a callable that returns a string.
:ref:`ratelimit-s... |
resets the storage if it supports being reset | def reset(self):
"""
resets the storage if it supports being reset
"""
try:
self._storage.reset()
self.logger.info("Storage has been reset and all limits cleared")
except NotImplementedError:
self.logger.warning("This storage type does not supp... |
Returns a bs4 object of the page requested | def get_soup(page=''):
"""
Returns a bs4 object of the page requested
"""
content = requests.get('%s/%s' % (BASE_URL, page)).text
return BeautifulSoup(content) |
Takes two names and returns true if they describe the same person. | def match(fullname1, fullname2, strictness='default', options=None):
"""
Takes two names and returns true if they describe the same person.
:param string fullname1: first human name
:param string fullname2: second human name
:param string strictness: strictness settings to use
:param dict optio... |
Takes two names and returns true if they describe the same person. Uses difflib s sequence matching on a per - field basis for names | def ratio(fullname1, fullname2, strictness='default', options=None):
"""
Takes two names and returns true if they describe the same person.
Uses difflib's sequence matching on a per-field basis for names
:param string fullname1: first human name
:param string fullname2: second human name
:param... |
Returns all tr tag rows as a list of tuples. Each tuple is for a single story. | def _get_zipped_rows(self, soup):
"""
Returns all 'tr' tag rows as a list of tuples. Each tuple is for
a single story.
"""
# the table with all submissions
table = soup.findChildren('table')[2]
# get all rows but last 2
rows = table.findChildren(['... |
Builds and returns a list of stories ( dicts ) from the passed source. | def _build_story(self, all_rows):
"""
Builds and returns a list of stories (dicts) from the passed source.
"""
# list to hold all stories
all_stories = []
for (info, detail) in all_rows:
#-- Get the into about a story --#
# split in 3 c... |
Yields a list of stories from the passed page of HN. story_type can be: \ t = top stories ( homepage ) ( default ) \ t news2 = page 2 of top stories \ t newest = most recent stories \ t best = best stories limit is the number of stories required from the given page. Defaults to 30. Cannot be more than 30. | def get_stories(self, story_type='', limit=30):
"""
Yields a list of stories from the passed page
of HN.
'story_type' can be:
\t'' = top stories (homepage) (default)
\t'news2' = page 2 of top stories
\t'newest' = most recent stories
\t'best' = best... |
Return the leaders of Hacker News | def get_leaders(self, limit=10):
""" Return the leaders of Hacker News """
if limit is None:
limit = 10
soup = get_soup('leaders')
table = soup.find('table')
leaders_table = table.find_all('table')[1]
listleaders = leaders_table.find_all('tr')[2:]
... |
Get the relative url of the next page ( The More link at the bottom of the page ) | def _get_next_page(self, soup, current_page):
"""
Get the relative url of the next page (The "More" link at
the bottom of the page)
"""
# Get the table with all the comments:
if current_page == 1:
table = soup.findChildren('table')[3]
elif cu... |
For the story builds and returns a list of Comment objects. | def _build_comments(self, soup):
"""
For the story, builds and returns a list of Comment objects.
"""
comments = []
current_page = 1
while True:
# Get the table holding all comments:
if current_page == 1:
table = soup.f... |
Initializes an instance of Story for given item_id. It is assumed that the story referenced by item_id is valid and does not raise any HTTP errors. item_id is an int. | def fromid(self, item_id):
"""
Initializes an instance of Story for given item_id.
It is assumed that the story referenced by item_id is valid
and does not raise any HTTP errors.
item_id is an int.
"""
if not item_id:
raise Exception('Need an i... |
Compare a list of names from a name component based on settings | def compare_name_component(list1, list2, settings, use_ratio=False):
"""
Compare a list of names from a name component based on settings
"""
if not list1[0] or not list2[0]:
not_required = not settings['required']
return not_required * 100 if use_ratio else not_required
if len(list1... |
Evaluates whether names match or one name is the initial of the other | def equate_initial(name1, name2):
"""
Evaluates whether names match, or one name is the initial of the other
"""
if len(name1) == 0 or len(name2) == 0:
return False
if len(name1) == 1 or len(name2) == 1:
return name1[0] == name2[0]
return name1 == name2 |
Evaluates whether names match or one name prefixes another | def equate_prefix(name1, name2):
"""
Evaluates whether names match, or one name prefixes another
"""
if len(name1) == 0 or len(name2) == 0:
return False
return name1.startswith(name2) or name2.startswith(name1) |
Evaluates whether names match based on common nickname patterns | def equate_nickname(name1, name2):
"""
Evaluates whether names match based on common nickname patterns
This is not currently used in any name comparison
"""
# Convert '-ie' and '-y' to the root name
nickname_regex = r'(.)\1(y|ie)$'
root_regex = r'\1'
name1 = re.sub(nickname_regex, root... |
Converts unicode - specific characters to their equivalent ascii | def make_ascii(word):
"""
Converts unicode-specific characters to their equivalent ascii
"""
if sys.version_info < (3, 0, 0):
word = unicode(word)
else:
word = str(word)
normalized = unicodedata.normalize('NFKD', word)
return normalized.encode('ascii', 'ignore').decode('utf... |
Returns sequence match ratio for two words | def seq_ratio(word1, word2):
"""
Returns sequence match ratio for two words
"""
raw_ratio = SequenceMatcher(None, word1, word2).ratio()
return int(round(100 * raw_ratio)) |
Updates the values in a nested dict while unspecified values will remain unchanged | def deep_update_dict(default, options):
"""
Updates the values in a nested dict, while unspecified values will remain
unchanged
"""
for key in options.keys():
default_setting = default.get(key)
new_setting = options.get(key)
if isinstance(default_setting, dict):
d... |
Get base output path for a list of songs for download. | def template_to_base_path(template, google_songs):
"""Get base output path for a list of songs for download."""
if template == os.getcwd() or template == '%suggested%':
base_path = os.getcwd()
else:
template = os.path.abspath(template)
song_paths = [template_to_filepath(template, song) for song in google_song... |
Create a bit string of the given length with the probability of each bit being set equal to bit_prob which defaults to. 5. | def random(cls, length, bit_prob=.5):
"""Create a bit string of the given length, with the probability of
each bit being set equal to bit_prob, which defaults to .5.
Usage:
# Create a random BitString of length 10 with mostly zeros.
bits = BitString.random(10, bit_prob=.... |
Create a crossover template with the given number of points. The crossover template can be used as a mask to crossover two bitstrings of the same length. | def crossover_template(cls, length, points=2):
"""Create a crossover template with the given number of points. The
crossover template can be used as a mask to crossover two
bitstrings of the same length.
Usage:
assert len(parent1) == len(parent2)
template = BitSt... |
Returns the number of bits set to True in the bit string. | def count(self):
"""Returns the number of bits set to True in the bit string.
Usage:
assert BitString('00110').count() == 2
Arguments: None
Return:
An int, the number of bits with value 1.
"""
result = 0
bits = self._bits
while bi... |
Wait for an event on any channel. | def drain_events(self, allowed_methods=None, timeout=None):
"""Wait for an event on any channel."""
return self.wait_multi(self.channels.values(), timeout=timeout) |
Wait for an event on a channel. | def wait_multi(self, channels, allowed_methods=None, timeout=None):
"""Wait for an event on a channel."""
chanmap = dict((chan.channel_id, chan) for chan in channels)
chanid, method_sig, args, content = self._wait_multiple(
chanmap.keys(), allowed_methods, timeout=timeout)
... |
Establish connection to the AMQP broker. | def establish_connection(self):
"""Establish connection to the AMQP broker."""
conninfo = self.connection
if not conninfo.hostname:
raise KeyError("Missing hostname for AMQP connection.")
if conninfo.userid is None:
raise KeyError("Missing user id for AMQP connect... |
Check if a queue has been declared. | def queue_exists(self, queue):
"""Check if a queue has been declared.
:rtype bool:
"""
try:
self.channel.queue_declare(queue=queue, passive=True)
except AMQPChannelException, e:
if e.amqp_reply_code == 404:
return False
raise ... |
Delete queue by name. | def queue_delete(self, queue, if_unused=False, if_empty=False):
"""Delete queue by name."""
return self.channel.queue_delete(queue, if_unused, if_empty) |
Declare a named queue. | def queue_declare(self, queue, durable, exclusive, auto_delete,
warn_if_exists=False, arguments=None):
"""Declare a named queue."""
if warn_if_exists and self.queue_exists(queue):
warnings.warn(QueueAlreadyExistsWarning(
QueueAlreadyExistsWarning.__doc__))
... |
Declare an named exchange. | def exchange_declare(self, exchange, type, durable, auto_delete):
"""Declare an named exchange."""
return self.channel.exchange_declare(exchange=exchange,
type=type,
durable=durable,
... |
Bind queue to an exchange using a routing key. | def queue_bind(self, queue, exchange, routing_key, arguments=None):
"""Bind queue to an exchange using a routing key."""
return self.channel.queue_bind(queue=queue,
exchange=exchange,
routing_key=routing_key,
... |
Receive a message from a declared queue by name. | def get(self, queue, no_ack=False):
"""Receive a message from a declared queue by name.
:returns: A :class:`Message` object if a message was received,
``None`` otherwise. If ``None`` was returned, it probably means
there was no messages waiting on the queue.
"""
... |
Returns an iterator that waits for one message at a time. | def consume(self, limit=None):
"""Returns an iterator that waits for one message at a time."""
for total_message_count in count():
if limit and total_message_count >= limit:
raise StopIteration
if not self.channel.is_open:
raise StopIteration
... |
Cancel a channel by consumer tag. | def cancel(self, consumer_tag):
"""Cancel a channel by consumer tag."""
if not self.channel.connection:
return
self.channel.basic_cancel(consumer_tag) |
Close the channel if open. | def close(self):
"""Close the channel if open."""
if self._channel and self._channel.is_open:
self._channel.close()
self._channel_ref = None |
Request specific Quality of Service. | def qos(self, prefetch_size, prefetch_count, apply_global=False):
"""Request specific Quality of Service."""
self.channel.basic_qos(prefetch_size, prefetch_count,
apply_global) |
If no channel exists a new one is requested. | def channel(self):
"""If no channel exists, a new one is requested."""
if not self._channel:
self._channel_ref = weakref.ref(self.connection.get_channel())
return self._channel |
Establish connection to the AMQP broker. | def establish_connection(self):
"""Establish connection to the AMQP broker."""
conninfo = self.connection
if not conninfo.hostname:
raise KeyError("Missing hostname for AMQP connection.")
if conninfo.userid is None:
raise KeyError("Missing user id for AMQP connect... |
Declare a consumer. | def declare_consumer(self, queue, no_ack, callback, consumer_tag,
nowait=False):
"""Declare a consumer."""
return self.channel.basic_consume(queue=queue,
no_ack=no_ack,
callback=callback,
... |
Returns an iterator that waits for one message at a time. | def consume(self, limit=None):
"""Returns an iterator that waits for one message at a time."""
for total_message_count in count():
if limit and total_message_count >= limit:
raise StopIteration
if not self.channel.is_open:
raise StopIteration
... |
Cancel a channel by consumer tag. | def cancel(self, consumer_tag):
"""Cancel a channel by consumer tag."""
if not self.channel.conn:
return
self.channel.basic_cancel(consumer_tag) |
Encapsulate data into a AMQP message. | def prepare_message(self, message_data, delivery_mode, priority=None,
content_type=None, content_encoding=None):
"""Encapsulate data into a AMQP message."""
return amqp.Message(message_data, properties={
"delivery_mode": delivery_mode,
"priority": priority... |
Special case serializer. | def raw_encode(data):
"""Special case serializer."""
content_type = 'application/data'
payload = data
if isinstance(payload, unicode):
content_encoding = 'utf-8'
payload = payload.encode(content_encoding)
else:
content_encoding = 'binary'
return content_type, content_enco... |
Register a encoder/ decoder for JSON serialization. | def register_json():
"""Register a encoder/decoder for JSON serialization."""
from anyjson import serialize as json_serialize
from anyjson import deserialize as json_deserialize
registry.register('json', json_serialize, json_deserialize,
content_type='application/json',
... |
Register a encoder/ decoder for YAML serialization. | def register_yaml():
"""Register a encoder/decoder for YAML serialization.
It is slower than JSON, but allows for more data types
to be serialized. Useful if you need to send data such as dates"""
try:
import yaml
registry.register('yaml', yaml.safe_dump, yaml.safe_load,
... |
The fastest serialization method but restricts you to python clients. | def register_pickle():
"""The fastest serialization method, but restricts
you to python clients."""
import cPickle
registry.register('pickle', cPickle.dumps, cPickle.loads,
content_type='application/x-python-serialize',
content_encoding='binary') |
See http:// msgpack. sourceforge. net/ | def register_msgpack():
"""See http://msgpack.sourceforge.net/"""
try:
import msgpack
registry.register('msgpack', msgpack.packs, msgpack.unpacks,
content_type='application/x-msgpack',
content_encoding='binary')
except ImportError:
def not_available(*... |
Register a new encoder/ decoder. | def register(self, name, encoder, decoder, content_type,
content_encoding='utf-8'):
"""Register a new encoder/decoder.
:param name: A convenience name for the serialization method.
:param encoder: A method that will be passed a python data structure
and should retu... |
Set the default serialization method used by this library. | def _set_default_serializer(self, name):
"""
Set the default serialization method used by this library.
:param name: The name of the registered serialization method.
For example, ``json`` (default), ``pickle``, ``yaml``,
or any custom methods registered using :meth:`regi... |
Serialize a data structure into a string suitable for sending as an AMQP message body. | def encode(self, data, serializer=None):
"""
Serialize a data structure into a string suitable for sending
as an AMQP message body.
:param data: The message data to send. Can be a list,
dictionary or a string.
:keyword serializer: An optional string representing
... |
Deserialize a data stream as serialized using encode based on: param: content_type. | def decode(self, data, content_type, content_encoding):
"""Deserialize a data stream as serialized using ``encode``
based on :param:`content_type`.
:param data: The message data to deserialize.
:param content_type: The content-type of the data.
(e.g., ``application/json``).... |
Acknowledge this message as being processed. This will remove the message from the queue. | def ack(self):
"""Acknowledge this message as being processed.,
This will remove the message from the queue.
:raises MessageStateError: If the message has already been
acknowledged/requeued/rejected.
"""
if self.acknowledged:
raise self.MessageStateError... |
Returns an iterator that waits for one message at a time. | def consume(self, limit=None):
"""Returns an iterator that waits for one message at a time."""
for total_message_count in count():
if limit and total_message_count >= limit:
raise StopIteration
self.drain_events()
yield True |
Create a bit string of the given length with the probability of each bit being set equal to bit_prob which defaults to. 5. | def random(cls, length, bit_prob=.5):
"""Create a bit string of the given length, with the probability of
each bit being set equal to bit_prob, which defaults to .5.
Usage:
# Create a random BitString of length 10 with mostly zeros.
bits = BitString.random(10, bit_prob=.... |
Create a crossover template with the given number of points. The crossover template can be used as a mask to crossover two bitstrings of the same length. | def crossover_template(cls, length, points=2):
"""Create a crossover template with the given number of points. The
crossover template can be used as a mask to crossover two
bitstrings of the same length.
Usage:
assert len(parent1) == len(parent2)
template = BitSt... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.