Search is not available for this dataset
text stringlengths 75 104k |
|---|
def serialize(obj):
"""JSON serializer that accepts datetime & date"""
from datetime import datetime, date, time
if isinstance(obj, date) and not isinstance(obj, datetime):
obj = datetime.combine(obj, time.min)
if isinstance(obj, datetime):
return obj.isoformat() |
def check(response, expected_status=200, url=None):
"""
Check whether the status code of the response equals expected_status and
raise an APIError otherwise.
@param url: The url of the response (for error messages).
Defaults to response.url
@param json: if True, return r.json(), othe... |
def _get_auth(self, user=None, password=None):
"""
Get the authentication info for the current user, from
1) a ~/.amcatauth file, which should be a csv file
containing host, username, password entries
2) the AMCAT_USER (or USER) and AMCAT_PASSWORD environment variables
... |
def request(self, url, method="get", format="json", data=None,
expected_status=None, headers=None, use_xpost=True, **options):
"""
Make an HTTP request to the given relative URL with the host,
user, and password information. Returns the deserialized json
if successful, an... |
def get_pages(self, url, page=1, page_size=100, yield_pages=False, **filters):
"""
Get all pages at url, yielding individual results
:param url: the url to fetch
:param page: start from this page
:param page_size: results per page
:param yield_pages: yield whole pages rat... |
def get_scroll(self, url, page_size=100, yield_pages=False, **filters):
"""
Scroll through the resource at url and yield the individual results
:param url: url to scroll through
:param page_size: results per page
:param yield_pages: yield whole pages rather than individual result... |
def get_status(self):
"""Get the AmCAT status page"""
url = URL.status.format(**locals())
return self.get_request(url) |
def aggregate(self, **filters):
"""Conduct an aggregate query"""
url = URL.aggregate.format(**locals())
return self.get_pages(url, **filters) |
def list_sets(self, project, **filters):
"""List the articlesets in a project"""
url = URL.articlesets.format(**locals())
return self.get_pages(url, **filters) |
def get_set(self, project, articleset, **filters):
"""List the articlesets in a project"""
url = URL.articleset.format(**locals())
return self.request(url, **filters) |
def list_articles(self, project, articleset, page=1, **filters):
"""List the articles in a set"""
url = URL.article.format(**locals())
return self.get_pages(url, page=page, **filters) |
def create_set(self, project, json_data=None, **options):
"""
Create a new article set. Provide the needed arguments using
post_data or with key-value pairs
"""
url = URL.articlesets.format(**locals())
if json_data is None:
# form encoded request
r... |
def create_articles(self, project, articleset, json_data=None, **options):
"""
Create one or more articles in the set. Provide the needed arguments
using the json_data or with key-value pairs
@param json_data: A dictionary or list of dictionaries. Each dict
can ... |
def sign(self, encoded):
""" Return authentication signature of encoded bytes """
signature = self._hmac.copy()
signature.update(encoded)
return signature.hexdigest().encode('utf-8') |
def split(self, encoded):
""" Split into signature and message """
maxlen = len(encoded) - self.sig_size
message = encoded[:maxlen]
signature = encoded[-self.sig_size:]
return message, signature |
def auth(self, encoded):
""" Validate integrity of encoded bytes """
message, signature = self.split(encoded)
computed = self.sign(message)
if not hmac.compare_digest(signature, computed):
raise AuthenticatorInvalidSignature |
def cached_classproperty(fun):
"""A memorization decorator for class properties.
It implements the above `classproperty` decorator, with
the difference that the function result is computed and attached
to class as direct attribute. (Lazy loading and caching.)
"""
@functools.wraps(fun)
def ... |
def plugin_method(*plugin_names):
"""Plugin Method decorator.
Signs a web handler function with the plugins to be applied as attributes.
Args:
plugin_names (list): A list of plugin callable names
Returns:
A wrapped handler callable.
Examples:
>>> @plugin_method('json', 'bi... |
def route_method(method_name, extra_part=False):
"""Custom handler routing decorator.
Signs a web handler callable with the http method as attribute.
Args:
method_name (str): HTTP method name (i.e GET, POST)
extra_part (bool): Indicates if wrapped callable name should be a part
... |
def issue_add(lancet, assign, add_to_sprint, summary):
"""
Create a new issue on the issue tracker.
"""
summary = " ".join(summary)
issue = create_issue(
lancet,
summary,
# project_id=project_id,
add_to_active_sprint=add_to_sprint,
)
if assign:
if assi... |
def _maybe_update(self, user, attribute, new_value):
"""
DRY helper. If the specified attribute of the user differs from the
specified value, it will be updated.
"""
old_value = getattr(user, attribute)
if new_value != old_value:
self.stderr.write(
... |
def _check_email_match(self, user, email):
"""
DRY helper.
Requiring the user to specify both username and email will help catch
certain issues, for example if the expected username has already been
taken by someone else.
"""
if user.email != email:
#... |
def credentials_checker(url, username, password):
"""Check the provided credentials using the Harvest API."""
api = HarvestAPI(url, (username, password))
try:
api.whoami()
except HarvestError:
return False
else:
return True |
def harvest(lancet, config_section):
"""Construct a new Harvest client."""
url, username, password = lancet.get_credentials(
config_section, credentials_checker
)
project_id_getter = lancet.get_instance_from_config(
"timer", "project_id_getter", lancet
)
task_id_getter = lancet.... |
def temp_dir(folder=None, delete=True):
# type: (Optional[str], bool) -> str
"""Get a temporary directory optionally with folder appended (and created if it doesn't exist)
Args:
folder (Optional[str]): Folder to create in temporary folder. Defaults to None.
delete (bool): Whether to delete ... |
def send(self, obj):
"""Send a push notification"""
if not isinstance(obj, NotificationMessage):
raise ValueError, u"You can only send NotificationMessage objects."
self._send_queue.put(obj) |
def get_error(self, block = True, timeout = None):
"""
Gets the next error message.
Each error message is a 2-tuple of (status, identifier)."""
return self._error_queue.get(block = block, timeout = timeout) |
def get_feedback(self, block = True, timeout = None):
"""
Gets the next feedback message.
Each feedback message is a 2-tuple of (timestamp, device_token)."""
if self._feedback_greenlet is None:
self._feedback_greenlet = gevent.spawn(self._feedback_loop)
return self._feedback_queue.get(block = block, timeo... |
def wait_send(self, timeout = None):
"""Wait until all queued messages are sent."""
self._send_queue_cleared.clear()
self._send_queue_cleared.wait(timeout = timeout) |
def start(self):
"""Start the message sending loop."""
if self._send_greenlet is None:
self._send_greenlet = gevent.spawn(self._send_loop) |
def stop(self, timeout = 10.0):
"""
Send all pending messages, close connection.
Returns True if no message left to sent. False if dirty.
- timeout: seconds to wait for sending remaining messages. disconnect
immedately if None.
"""
if (self._send_greenlet is not None) and \
(self._send_queue.qsiz... |
def convert_to_ssml(text, text_format):
"""
Convert text to SSML based on the text's current format. NOTE: This module
is extremely limited at the moment and will be expanded.
:param text:
The text to convert.
:param text_format:
The text format of the text. Currently supports 'plai... |
def html_to_ssml(text):
"""
Replaces specific html tags with probable SSML counterparts.
"""
ssml_text = reduce(lambda x, y: x.replace(y, html_to_ssml_maps[y]), html_to_ssml_maps, text)
return ssml_text |
def multiple_replace(string, replacements):
# type: (str, Dict[str,str]) -> str
"""Simultaneously replace multiple strigns in a string
Args:
string (str): Input string
replacements (Dict[str,str]): Replacements dictionary
Returns:
str: String with replacements
"""
patt... |
def get_matching_text_in_strs(a, b, match_min_size=30, ignore='', end_characters=''):
# type: (str, str, int, str, str) -> List[str]
"""Returns a list of matching blocks of text in a and b
Args:
a (str): First string to match
b (str): Second string to match
match_min_size (int): Min... |
def get_matching_text(string_list, match_min_size=30, ignore='', end_characters='.!\r\n'):
# type: (List[str], int, str, str) -> str
"""Returns a string containing matching blocks of text in a list of strings followed by non-matching.
Args:
string_list (List[str]): List of strings to match
... |
def get_matching_then_nonmatching_text(string_list, separator='', match_min_size=30, ignore='',
end_characters='.!\r\n'):
# type: (List[str], str, int, str, str) -> str
"""Returns a string containing matching blocks of text in a list of strings followed by non-matching.
... |
def iexpand(string, keep_escapes=False):
"""Expand braces and return an iterator."""
if isinstance(string, bytes):
is_bytes = True
string = string.decode('latin-1')
else:
is_bytes = False
if is_bytes:
return (entry.encode('latin-1') for entry in ExpandBrace(keep_escape... |
def set_expanding(self):
"""Set that we are expanding a sequence, and return whether a release is required by the caller."""
status = not self.expanding
if status:
self.expanding = True
return status |
def get_escape(self, c, i):
"""Get an escape."""
try:
escaped = next(i)
except StopIteration:
escaped = ''
return c + escaped if self.keep_escapes else escaped |
def squash(self, a, b):
"""
Returns a generator that squashes two iterables into one.
```
['this', 'that'], [[' and', ' or']] => ['this and', 'this or', 'that and', 'that or']
```
"""
return ((''.join(x) if isinstance(x, tuple) else x) for x in itertools.product... |
def get_literals(self, c, i, depth):
"""
Get a string literal.
Gather all the literal chars up to opening curly or closing brace.
Also gather chars between braces and commas within a group (is_expanding).
"""
result = ['']
is_dollar = False
try:
... |
def combine(self, a, b):
"""A generator that combines two iterables."""
for l in (a, b):
for x in l:
yield x |
def get_sequence(self, c, i, depth):
"""
Get the sequence.
Get sequence between `{}`, such as: `{a,b}`, `{1..2[..inc]}`, etc.
It will basically crawl to the end or find a valid series.
"""
result = []
release = self.set_expanding()
has_comma = False # U... |
def get_range(self, i):
"""
Check and retrieve range if value is a valid range.
Here we are looking to see if the value is series or range.
We look for `{1..2[..inc]}` or `{a..z[..inc]}` (negative numbers are fine).
"""
try:
m = i.match(RE_INT_ITER)
... |
def format_value(self, value, padding):
"""Get padding adjusting for negative values."""
# padding = padding - 1 if value < 0 and padding > 0 else padding
# prefix = '-' if value < 0 else ''
if padding:
return "{:0{pad}d}".format(value, pad=padding)
else:
... |
def get_int_range(self, start, end, increment=None):
"""Get an integer range between start and end and increments of increment."""
first, last = int(start), int(end)
increment = int(increment) if increment is not None else 1
max_length = max(len(start), len(end))
# Zero doesn't... |
def get_char_range(self, start, end, increment=None):
"""Get a range of alphabetic characters."""
increment = int(increment) if increment else 1
if increment < 0:
increment = -increment
# Zero doesn't make sense as an incrementer
# but like bash, just assume one
... |
def expand(self, string):
"""Expand."""
self.expanding = False
empties = []
found_literal = False
if string:
i = iter(StringIter(string))
for x in self.get_literals(next(i), i, 0):
# We don't want to return trailing empty strings.
... |
def merge_two_dictionaries(a, b, merge_lists=False):
# type: (DictUpperBound, DictUpperBound, bool) -> DictUpperBound
"""Merges b into a and returns merged result
NOTE: tuples and arbitrary objects are not handled as it is totally ambiguous what should happen
Args:
a (DictUpperBound): dictiona... |
def merge_dictionaries(dicts, merge_lists=False):
# type: (List[DictUpperBound], bool) -> DictUpperBound
"""Merges all dictionaries in dicts into a single dictionary and returns result
Args:
dicts (List[DictUpperBound]): Dictionaries to merge into the first one in the list
merge_lists (bool... |
def dict_diff(d1, d2, no_key='<KEYNOTFOUND>'):
# type: (DictUpperBound, DictUpperBound, str) -> Dict
"""Compares two dictionaries
Args:
d1 (DictUpperBound): First dictionary to compare
d2 (DictUpperBound): Second dictionary to compare
no_key (str): What value to use if key is not fo... |
def dict_of_lists_add(dictionary, key, value):
# type: (DictUpperBound, Any, Any) -> None
"""Add value to a list in a dictionary by key
Args:
dictionary (DictUpperBound): Dictionary to which to add values
key (Any): Key within dictionary
value (Any): Value to add to list in dictiona... |
def dict_of_sets_add(dictionary, key, value):
# type: (DictUpperBound, Any, Any) -> None
"""Add value to a set in a dictionary by key
Args:
dictionary (DictUpperBound): Dictionary to which to add values
key (Any): Key within dictionary
value (Any): Value to add to set in dictionary
... |
def list_distribute_contents_simple(input_list, function=lambda x: x):
# type: (List, Callable[[Any], Any]) -> List
"""Distribute the contents of a list eg. [1, 1, 1, 2, 2, 3] -> [1, 2, 3, 1, 2, 1]. List can contain complex types
like dictionaries in which case the function can return the appropriate value ... |
def list_distribute_contents(input_list, function=lambda x: x):
# type: (List, Callable[[Any], Any]) -> List
"""Distribute the contents of a list eg. [1, 1, 1, 2, 2, 3] -> [1, 2, 1, 2, 1, 3]. List can contain complex types
like dictionaries in which case the function can return the appropriate value eg. la... |
def extract_list_from_list_of_dict(list_of_dict, key):
# type: (List[DictUpperBound], Any) -> List
"""Extract a list by looking up key in each member of a list of dictionaries
Args:
list_of_dict (List[DictUpperBound]): List of dictionaries
key (Any): Key to find in each dictionary
Retu... |
def key_value_convert(dictin, keyfn=lambda x: x, valuefn=lambda x: x, dropfailedkeys=False, dropfailedvalues=False,
exception=ValueError):
# type: (DictUpperBound, Callable[[Any], Any], Callable[[Any], Any], bool, bool, ExceptionUpperBound) -> Dict
"""Convert keys and/or values of dictiona... |
def integer_key_convert(dictin, dropfailedkeys=False):
# type: (DictUpperBound, bool) -> Dict
"""Convert keys of dictionary to integers
Args:
dictin (DictUpperBound): Input dictionary
dropfailedkeys (bool): Whether to drop dictionary entries where key conversion fails. Defaults to False.
... |
def integer_value_convert(dictin, dropfailedvalues=False):
# type: (DictUpperBound, bool) -> Dict
"""Convert values of dictionary to integers
Args:
dictin (DictUpperBound): Input dictionary
dropfailedvalues (bool): Whether to drop dictionary entries where key conversion fails. Defaults to F... |
def float_value_convert(dictin, dropfailedvalues=False):
# type: (DictUpperBound, bool) -> Dict
"""Convert values of dictionary to floats
Args:
dictin (DictUpperBound): Input dictionary
dropfailedvalues (bool): Whether to drop dictionary entries where key conversion fails. Defaults to False... |
def avg_dicts(dictin1, dictin2, dropmissing=True):
# type: (DictUpperBound, DictUpperBound, bool) -> Dict
"""Create a new dictionary from two dictionaries by averaging values
Args:
dictin1 (DictUpperBound): First input dictionary
dictin2 (DictUpperBound): Second input dictionary
dro... |
def read_list_from_csv(filepath, dict_form=False, headers=None, **kwargs):
# type: (str, bool, Union[int, List[int], List[str], None], Any) -> List[Union[Dict, List]]
"""Read a list of rows in dict or list form from a csv. (The headers argument is either a row
number or list of row numbers (in case of mu... |
def write_list_to_csv(list_of_rows, filepath, headers=None):
# type: (List[Union[DictUpperBound, List]], str, Union[int, List[int], List[str], None]) -> None
"""Write a list of rows in dict or list form to a csv. (The headers argument is either a row
number or list of row numbers (in case of multi-line h... |
def args_to_dict(args):
# type: (str) -> DictUpperBound[str,str]
"""Convert command line arguments in a comma separated string to a dictionary
Args:
args (str): Command line arguments
Returns:
DictUpperBound[str,str]: Dictionary of arguments
"""
arguments = dict()
for arg ... |
def compare_files(path1, path2):
# type: (str, str) -> List[str]
"""Returns the delta between two files using -, ?, + format excluding
lines that are the same
Args:
path1 (str): Path to first file
path2 (str): Path to second file
Returns:
List[str]: Delta between the two fi... |
def assert_files_same(path1, path2):
# type: (str, str) -> None
"""Asserts that two files are the same and returns delta using
-, ?, + format if not
Args:
path1 (str): Path to first file
path2 (str): Path to second file
Returns:
None
"""
difflines = compare_files(p... |
def main():
"""Entry point when called on the command-line.
"""
# Locale
locale.setlocale(locale.LC_ALL, '')
# Encoding for output streams
if str == bytes: # PY2
writer = codecs.getwriter(locale.getpreferredencoding())
o_stdout, o_stderr = sys.stdout, sys.stderr
sys.std... |
def apply(self, callback, context): # pragma: no cover
"""Apply the HTTPError wrapper to the callback.
"""
def wrapper(*args, **kwargs):
try:
return callback(*args, **kwargs)
except bottle.HTTPError as error:
return self.error_wrapper.fro... |
def add_episode(self, text, text_format, title, author, summary=None,
publish_date=None, synthesizer='watson', synth_args=None, sentence_break='. '):
"""
Add a new episode to the podcast.
:param text:
See :meth:`Episode`.
:param text_format:
S... |
def add_scheduled_job(self, text_source, cron_args, text_format, title, author, summary=None,
synthesizer='watson', synth_args=None, sentence_break='. '):
"""
Add and start a new scheduled job to dynamically generate podcasts.
Note: scheduling will end when the process... |
def publish(self, titles):
"""
Publish a set of episodes to the Podcast's RSS feed.
:param titles:
Either a single episode title or a sequence of episode titles to
publish.
"""
if isinstance(titles, Sequence) and not isinstance(titles, six.string_types):
... |
def render_audio(self):
"""
Synthesize audio from the episode's text.
"""
segment = text_to_speech(self._text, self.synthesizer, self.synth_args, self.sentence_break)
milli = len(segment)
seconds = '{0:.1f}'.format(float(milli) / 1000 % 60).zfill(2)
minutes = '{0... |
def publish(self):
"""
Mark an episode as published.
"""
if self.published is False:
self.published = True
else:
raise Warning(self.title + ' is already published.') |
def unpublish(self):
"""
Mark an episode as not published.
"""
if self.published is True:
self.published = False
else:
raise Warning(self.title + ' is already not published.') |
def _environment_variables(**kwargs):
# type: (Any) -> Any
"""
Overwrite keyword arguments with environment variables
Args:
**kwargs: See below
user_agent (str): User agent string.
Returns:
kwargs: Changed keyword arguments
"""
... |
def _construct(configdict, prefix, ua):
# type: (Dict, str, str) -> str
"""
Construct user agent
Args:
configdict (str): Additional configuration for user agent
prefix (str): Text to put at start of user agent
ua (str): Custom user agent text
... |
def _load(cls, prefix, user_agent_config_yaml, user_agent_lookup=None):
# type: (str, str, Optional[str]) -> str
"""
Load user agent YAML file
Args:
prefix (str): Text to put at start of user agent
user_agent_config_yaml (str): Path to user agent YAML file
... |
def _create(cls, user_agent=None, user_agent_config_yaml=None,
user_agent_lookup=None, **kwargs):
# type: (Optional[str], Optional[str], Optional[str], Any) -> str
"""
Get full user agent string
Args:
user_agent (Optional[str]): User agent string. HDXPythonLi... |
def set_global(cls, user_agent=None, user_agent_config_yaml=None,
user_agent_lookup=None, **kwargs):
# type: (Optional[str], Optional[str], Optional[str], Any) -> None
"""
Set global user agent string
Args:
user_agent (Optional[str]): User agent string. HD... |
def get(cls, user_agent=None, user_agent_config_yaml=None, user_agent_lookup=None, **kwargs):
# type: (Optional[str], Optional[str], Optional[str], Any) -> str
"""
Get full user agent string from parameters if supplied falling back on global user agent if set.
Args:
user_age... |
def save_yaml(dictionary, path, pretty=False, sortkeys=False):
# type: (Dict, str, bool, bool) -> None
"""Save dictionary to YAML file preserving order if it is an OrderedDict
Args:
dictionary (Dict): Python dictionary to save
path (str): Path to YAML file
pretty (bool): Whether to ... |
def save_json(dictionary, path, pretty=False, sortkeys=False):
# type: (Dict, str, bool, bool) -> None
"""Save dictionary to JSON file preserving order if it is an OrderedDict
Args:
dictionary (Dict): Python dictionary to save
path (str): Path to JSON file
pretty (bool): Whether to ... |
def load_yaml(path):
# type: (str) -> OrderedDict
"""Load YAML file into an ordered dictionary
Args:
path (str): Path to YAML file
Returns:
OrderedDict: Ordered dictionary containing loaded YAML file
"""
with open(path, 'rt') as f:
yamldict = yaml.load(f.read(), Loader=... |
def load_json(path):
# type: (str) -> OrderedDict
"""Load JSON file into an ordered dictionary
Args:
path (str): Path to JSON file
Returns:
OrderedDict: Ordered dictionary containing loaded JSON file
"""
with open(path, 'rt') as f:
jsondict = json.loads(f.read(), object... |
def load_file_to_str(path):
# type: (str) -> str
"""
Load file into a string removing newlines
Args:
path (str): Path to file
Returns:
str: String contents of file
"""
with open(path, 'rt') as f:
string = f.read().replace(linesep, '')
if not string:
rai... |
def contributors(lancet, output):
"""
List all contributors visible in the git history.
"""
sorting = pygit2.GIT_SORT_TIME | pygit2.GIT_SORT_REVERSE
commits = lancet.repo.walk(lancet.repo.head.target, sorting)
contributors = ((c.author.name, c.author.email) for c in commits)
contributors = O... |
def text_to_speech(text, synthesizer, synth_args, sentence_break):
"""
Converts given text to a pydub AudioSegment using a specified speech
synthesizer. At the moment, IBM Watson's text-to-speech API is the only
available synthesizer.
:param text:
The text that will be synthesized to audio.... |
def watson_request(text, synth_args):
"""
Makes a single request to the IBM Watson text-to-speech API.
:param text:
The text that will be synthesized to audio.
:param synth_args:
A dictionary of arguments to add to the request. These should include
username and password for auth... |
def build_rss_feed(podcast):
"""
Builds a podcast RSS feed and returns an xml file.
:param podcast:
A Podcast model to build the RSS feed from.
"""
if not os.path.exists(podcast.output_path):
os.makedirs(podcast.output_path)
rss = ET.Element('rss', attrib={'xmlns:itunes': 'http... |
def get(self, uid=None):
"""Example retrieve API method.
"""
# Return resource collection
if uid is None:
return self.response_factory.ok(data=resource_db)
# Return resource based on UID.
try:
record = [r for r in resource_db if r.get('id') == u... |
def post(self):
"""Example POST method.
"""
resource_data = self.request.json
record = {'id': str(len(resource_db) + 1),
'name': resource_data.get('name')}
resource_db.append(record)
return self.response_factory.ok(data=record) |
def put(self, uid):
"""Example PUT method.
"""
resource_data = self.request.json
try:
record = resource_db[uid]
except KeyError:
return self.response_factory.not_found(errors=['Resource with UID {} does not exist!'])
record['name'] = resource_d... |
def delete(self, uid):
"""Example DELETE method.
"""
try:
record = resource_db[uid].copy()
except KeyError:
return self.response_factory.not_found(errors=['Resource with UID {} does not exist!'])
del resource_db[uid]
return self.response_factory... |
def get_pages(url):
"""
Return the 'pages' from the starting url
Technically, look for the 'next 50' link, yield and download it, repeat
"""
while True:
yield url
doc = html.parse(url).find("body")
links = [a for a in doc.findall(".//a") if a.text and a.text.startswith("next... |
def get_article_urls(url):
"""
Return the articles from a page
Technically, look for a div with class mw-search-result-heading
and get the first link from this div
"""
doc = html.parse(url).getroot()
for div in doc.cssselect("div.mw-search-result-heading"):
href = div.cssselect("a")[... |
def get_article(url):
"""
Return a single article as a 'amcat-ready' dict
Uses the 'export' function of wikinews to get an xml article
"""
a = html.parse(url).getroot()
title = a.cssselect(".firstHeading")[0].text_content()
date = a.cssselect(".published")[0].text_content()
date = dateti... |
def scrape_wikinews(conn, project, articleset, query):
"""
Scrape wikinews articles from the given query
@param conn: The AmcatAPI object
@param articleset: The target articleset ID
@param category: The wikinews category name
"""
url = "http://en.wikinews.org/w/index.php?search={}&limit=50".... |
def start_service(addr, n):
""" Start a service """
s = Service(addr)
started = time.time()
for _ in range(n):
msg = s.socket.recv()
s.socket.send(msg)
s.socket.close()
duration = time.time() - started
print('Raw REP service stats:')
util.print_stats(n, duration)
re... |
def bench(client, n):
""" Benchmark n requests """
items = list(range(n))
# Time client publish operations
# ------------------------------
started = time.time()
msg = b'x'
for i in items:
client.socket.send(msg)
res = client.socket.recv()
assert msg == res
durat... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.