text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def div(self, key, value=2):
"""Divides the specified key value by the specified value. :param str|unicode key: :param int value: :rtype: bool """ |
return uwsgi.cache_mul(key, value, self.timeout, self.name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def recv(request_context=None, non_blocking=False):
"""Receives data from websocket. :param request_context: :param bool non_blocking: :rtype: bytes|str :raises IOError: If unable to receive a message. """ |
if non_blocking:
result = uwsgi.websocket_recv_nb(request_context)
else:
result = uwsgi.websocket_recv(request_context)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send(message, request_context=None, binary=False):
"""Sends a message to websocket. :param str message: data to send :param request_context: :raises IOError: If unable to send a message. """ |
if binary:
return uwsgi.websocket_send_binary(message, request_context)
return uwsgi.websocket_send(message, request_context) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parser_feed(parser, text):
"""Direct wrapper over cmark_parser_feed.""" |
encoded_text = text.encode('utf-8')
return _cmark.lib.cmark_parser_feed(
parser, encoded_text, len(encoded_text)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_syntax_extension(name):
"""Direct wrapper over cmark_find_syntax_extension.""" |
encoded_name = name.encode('utf-8')
extension = _cmark.lib.cmark_find_syntax_extension(encoded_name)
if extension == _cmark.ffi.NULL:
return None
else:
return extension |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_item(self, key, value, cache_name=None):
"""Add an item into the given cache. This is a commodity option (mainly useful for testing) allowing you to store an item in a uWSGI cache during startup. :param str|unicode key: :param value: :param str|unicode cache_name: If not set, default will be used. """ |
cache_name = cache_name or ''
value = '%s %s=%s' % (cache_name, key, value)
self._set('add-cache-item', value.strip(), multi=True)
return self._section |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_file(self, filepath, gzip=False, cache_name=None):
"""Load a static file in the cache. .. note:: Items are stored with the filepath as is (relative or absolute) as the key. :param str|unicode filepath: :param bool gzip: Use gzip compression. :param str|unicode cache_name: If not set, default will be used. """ |
command = 'load-file-in-cache'
if gzip:
command += '-gzip'
cache_name = cache_name or ''
value = '%s %s' % (cache_name, filepath)
self._set(command, value.strip(), multi=True)
return self._section |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def register_timer(period, target=None):
"""Add timer. Can be used as a decorator: .. code-block:: python @register_timer(3) def repeat():
do() :param int period: The interval (seconds) at which to raise the signal. :param int|Signal|str|unicode target: Existing signal to raise or Signal Target to register signal implicitly. Available targets: * ``workers`` - run the signal handler on all the workers * ``workerN`` - run the signal handler only on worker N * ``worker``/``worker0`` - run the signal handler on the first available worker * ``active-workers`` - run the signal handlers on all the active [non-cheaped] workers * ``mules`` - run the signal handler on all of the mules * ``muleN`` - run the signal handler on mule N * ``mule``/``mule0`` - run the signal handler on the first available mule * ``spooler`` - run the signal on the first available spooler * ``farmN/farm_XXX`` - run the signal handler in the mule farm N or named XXX :rtype: bool|callable :raises ValueError: If unable to add timer. """ |
return _automate_signal(target, func=lambda sig: uwsgi.add_timer(int(sig), period)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def register_cron(weekday=None, month=None, day=None, hour=None, minute=None, target=None):
"""Adds cron. The interface to the uWSGI signal cron facility. .. code-block:: python @register_cron(hour=-3) # Every 3 hours. def repeat():
do() .. note:: Arguments work similarly to a standard crontab, but instead of "*", use -1, and instead of "/2", "/3", etc. use -2 and -3, etc. .. note:: Periods - rules like hour='10-18/2' (from 10 till 18 every 2 hours) - are allowed, but they are emulated by uwsgiconf. Use strings to define periods. Keep in mind, that your actual function will be wrapped into another one, which will check whether it is time to call your function. :param int|str|unicode weekday: Day of a the week number. Defaults to `each`. 0 - Sunday 1 - Monday 2 - Tuesday 3 - Wednesday 4 - Thursday 5 - Friday 6 - Saturday :param int|str|unicode month: Month number 1-12. Defaults to `each`. :param int|str|unicode day: Day of the month number 1-31. Defaults to `each`. :param int|str|unicode hour: Hour 0-23. Defaults to `each`. :param int|str|unicode minute: Minute 0-59. Defaults to `each`. :param int|Signal|str|unicode target: Existing signal to raise or Signal Target to register signal implicitly. Available targets: * ``workers`` - run the signal handler on all the workers * ``workerN`` - run the signal handler only on worker N * ``worker``/``worker0`` - run the signal handler on the first available worker * ``active-workers`` - run the signal handlers on all the active [non-cheaped] workers * ``mules`` - run the signal handler on all of the mules * ``muleN`` - run the signal handler on mule N * ``mule``/``mule0`` - run the signal handler on the first available mule * ``spooler`` - run the signal on the first available spooler * ``farmN/farm_XXX`` - run the signal handler in the mule farm N or named XXX :rtype: bool|callable :raises ValueError: If unable to add cron rule. """ |
task_args_initial = {name: val for name, val in locals().items() if val is not None and name != 'target'}
task_args_casted = {}
def skip_task(check_funcs):
now = datetime.now()
allright = all((func(now) for func in check_funcs))
return not allright
def check_date(now, attr, target_range):
attr = getattr(now, attr)
if callable(attr): # E.g. weekday.
attr = attr()
return attr in target_range
check_date_funcs = []
for name, val in task_args_initial.items():
# uWSGI won't accept strings, so we emulate ranges here.
if isinstance(val, string_types):
# Rules like 10-18/2 (from 10 till 18 every 2 hours).
val, _, step = val.partition('/')
step = int(step) if step else 1
start, _, end = val.partition('-')
if not (start and end):
raise RuntimeConfigurationError(
'String cron rule without a range is not supported. Use integer notation.')
start = int(start)
end = int(end)
now_attr_name = name
period_range = set(range(start, end+1, step))
if name == 'weekday':
# Special case for weekday indexes: swap uWSGI Sunday 0 for ISO Sunday 7.
now_attr_name = 'isoweekday'
if 0 in period_range:
period_range.discard(0)
period_range.add(7)
# Gather date checking functions in one place.
check_date_funcs.append(partial(check_date, attr=now_attr_name, target_range=period_range))
# Use minimal duration (-1).
val = None
task_args_casted[name] = val
if not check_date_funcs:
# No special handling of periods, quit early.
args = [(-1 if arg is None else arg) for arg in (minute, hour, day, month, weekday)]
return _automate_signal(target, func=lambda sig: uwsgi.add_cron(int(sig), *args))
skip_task = partial(skip_task, check_date_funcs)
def decor(func_action):
"""Decorator wrapping."""
@wraps(func_action)
def func_action_wrapper(*args, **kwargs):
"""Action function wrapper to handle periods in rules."""
if skip_task():
# todo Maybe allow user defined value for this return.
return None
return func_action(*args, **kwargs)
args = []
for arg_name in ['minute', 'hour', 'day', 'month', 'weekday']:
arg = task_args_casted.get(arg_name, None)
args.append(-1 if arg is None else arg)
return _automate_signal(target, func=lambda sig: uwsgi.add_cron(int(sig), *args))(func_action_wrapper)
return decor |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def truncate_ellipsis(line, length=30):
|
l = len(line)
return line if l < length else line[:length - 3] + "..." |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pyle_evaluate(expressions=None, modules=(), inplace=False, files=None, print_traceback=False):
"""The main method of pyle.""" |
eval_globals = {}
eval_globals.update(STANDARD_MODULES)
for module_arg in modules or ():
for module in module_arg.strip().split(","):
module = module.strip()
if module:
eval_globals[module] = __import__(module)
if not expressions:
# Default 'do nothing' program
expressions = ['line']
files = files or ['-']
eval_locals = {}
for file in files:
if file == '-':
file = sys.stdin
out_buf = sys.stdout if not inplace else StringIO.StringIO()
out_line = None
with (open(file, 'rb') if not hasattr(file, 'read') else file) as in_file:
for num, line in enumerate(in_file.readlines()):
was_whole_line = False
if line[-1] == '\n':
was_whole_line = True
line = line[:-1]
expr = ""
try:
for expr in expressions:
words = [word.strip()
for word in re.split(r'\s+', line)
if word]
eval_locals.update({
'line': line, 'words': words,
'filename': in_file.name, 'num': num
})
out_line = eval(expr, eval_globals, eval_locals)
if out_line is None:
continue
# If the result is something list-like or iterable,
# output each item space separated.
if not isinstance(out_line, str) and not isinstance(out_line, unicode):
try:
out_line = u' '.join(unicode(part)
for part in out_line)
except:
# Guess it wasn't a list after all.
out_line = unicode(out_line)
line = out_line
except Exception as e:
sys.stdout.flush()
sys.stderr.write("At %s:%d ('%s'): `%s`: %s\n" % (
in_file.name, num, truncate_ellipsis(line), expr, e))
if print_traceback:
traceback.print_exc(None, sys.stderr)
else:
if out_line is None:
continue
out_line = out_line or u''
out_buf.write(out_line)
if was_whole_line:
out_buf.write('\n')
if inplace:
with open(file, 'wb') as out_file:
out_file.write(out_buf.getvalue())
out_buf.close() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pyle(argv=None):
"""Execute pyle with the specified arguments, or sys.argv if no arguments specified.""" |
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("-m", "--modules", dest="modules", action='append',
help="import MODULE before evaluation. May be specified more than once.")
parser.add_argument("-i", "--inplace", dest="inplace", action='store_true', default=False,
help="edit files in place. When used with file name arguments, the files will be replaced by the output of the evaluation")
parser.add_argument("-e", "--expression", action="append",
dest="expressions", help="an expression to evaluate for each line")
parser.add_argument('files', nargs='*',
help="files to read as input. If used with --inplace, the files will be replaced with the output")
parser.add_argument("--traceback", action="store_true", default=False,
help="print a traceback on stderr when an expression fails for a line")
args = parser.parse_args() if not argv else parser.parse_args(argv)
pyle_evaluate(args.expressions, args.modules, args.inplace, args.files,
args.traceback) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_login_form_component(self):
"""Initializes and returns the login form component @rtype: LoginForm @return: Initialized component """ |
self.dw.wait_until(
lambda: self.dw.is_present(LoginForm.locators.form),
failure_message='login form was never present so could not get the model '
'upload form component'
)
self.login_form = LoginForm(
parent_page=self,
element=self.dw.find(LoginForm.locators.form),
)
return self.login_form |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def __add_query_comment(sql):
""" Adds a comment line to the query to be executed containing the line number of the calling function. This is useful for debugging slow queries, as the comment will show in the slow query log @type sql: str @param sql: sql needing comment @return: """ |
# Inspect the call stack for the originating call
file_name = ''
line_number = ''
caller_frames = inspect.getouterframes(inspect.currentframe())
for frame in caller_frames:
if "ShapewaysDb" not in frame[1]:
file_name = frame[1]
line_number = str(frame[2])
break
comment = "/*COYOTE: Q_SRC: {file}:{line} */\n".format(file=file_name, line=line_number)
return comment + sql, |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_single_instance(sql, class_type, *args, **kwargs):
"""Returns an instance of class_type populated with attributes from the DB record; throws an error if no records are found @param sql: Sql statement to execute @param class_type: The type of class to instantiate and populate with DB record @return: Return an instance with attributes set to values from DB """ |
record = CoyoteDb.get_single_record(sql, *args, **kwargs)
try:
instance = CoyoteDb.get_object_from_dictionary_representation(dictionary=record, class_type=class_type)
except AttributeError:
raise NoRecordsFoundException('No records found for {class_type} with sql run on {host}: \n {sql}'.format(
sql=sql,
host=DatabaseConfig().get('mysql_host'),
class_type=class_type
))
return instance |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_all_instances(sql, class_type, *args, **kwargs):
"""Returns a list of instances of class_type populated with attributes from the DB record @param sql: Sql statement to execute @param class_type: The type of class to instantiate and populate with DB record @return: Return a list of instances with attributes set to values from DB """ |
records = CoyoteDb.get_all_records(sql, *args, **kwargs)
instances = [CoyoteDb.get_object_from_dictionary_representation(
dictionary=record, class_type=class_type) for record in records]
for instance in instances:
instance._query = sql
return instances |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def escape_dictionary(dictionary, datetime_format='%Y-%m-%d %H:%M:%S'):
"""Escape dictionary values with keys as column names and values column values @type dictionary: dict @param dictionary: Key-values """ |
for k, v in dictionary.iteritems():
if isinstance(v, datetime.datetime):
v = v.strftime(datetime_format)
if isinstance(v, basestring):
v = CoyoteDb.db_escape(str(v))
v = '"{}"'.format(v)
if v is True:
v = 1
if v is False:
v = 0
if v is None:
v = 'NULL'
dictionary[k] = v |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_insert_fields_and_values_from_dict(dictionary, datetime_format='%Y-%m-%d %H:%M:%S', db_escape=True):
"""Formats a dictionary to strings of fields and values for insert statements @param dictionary: The dictionary whose keys and values are to be inserted @param db_escape: If true, will db escape values @return: Tuple of strings containing string fields and values, e.g. ('user_id, username', '5, "pandaman"') """ |
if db_escape:
CoyoteDb.escape_dictionary(dictionary, datetime_format=datetime_format)
fields = get_delimited_string_from_list(dictionary.keys(), delimiter=',') # keys have no quotes
vals = get_delimited_string_from_list(dictionary.values(), delimiter=',') # strings get quotes
return fields, vals |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_kwargs(**kwargs):
"""This method should be used in query functions where user can query on any number of fields """ |
d = dict()
for k, v in kwargs.iteritems():
if v is not NOTSET:
d[k] = v
return d |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_update_clause_from_dict(dictionary, datetime_format='%Y-%m-%d %H:%M:%S'):
"""Builds the update values clause of an update statement based on the dictionary representation of an instance""" |
items = []
CoyoteDb.escape_dictionary(dictionary, datetime_format=datetime_format)
for k,v in dictionary.iteritems():
item = '{k} = {v}'.format(k=k, v=v)
items.append(item)
clause = ', '.join(item for item in items)
return clause |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_where_clause_from_dict(dictionary, join_operator='AND'):
"""Builds a where clause from a dictionary """ |
CoyoteDb.escape_dictionary(dictionary)
clause = join_operator.join(
(' {k} is {v} ' if str(v).lower() == 'null' else ' {k} = {v} ').format(k=k, v=v) # IS should be the operator for null values
for k, v in dictionary.iteritems())
return clause |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_dictionary_representation_of_object_attributes(obj, omit_null_fields=False):
"""Returns a dictionary of object's attributes, ignoring methods @param obj: The object to represent as dict @param omit_null_fields: If true, will not include fields in the dictionary that are null @return: Dictionary of the object's attributes """ |
obj_dictionary = obj.__dict__
obj_dictionary_temp = obj_dictionary.copy()
for k, v in obj_dictionary.iteritems():
if omit_null_fields:
if v is None:
obj_dictionary_temp.pop(k, None)
if k.startswith('_'):
obj_dictionary_temp.pop(k, None)
return obj_dictionary_temp |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def build_where_clause(mappings, operator='AND'):
"""Constructs the where clause based on a dictionary of values """ |
where_clause_mappings = {}
where_clause_mappings.update(mappings)
where_clause = 'WHERE ' + ' {} '.format(operator).join(
'{k} = {v}'.format(k=k, v='"{}"'.format(v) if isinstance(v, basestring) else v)
for k, v in where_clause_mappings.iteritems()
)
return where_clause |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_and_commit(*args, **kwargs):
"""Executes and commits the sql statement @return: None """ |
db, cursor = CoyoteDb.execute(*args, **kwargs)
db.commit()
return cursor |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update(sql, *args, **kwargs):
"""Updates and commits with an insert sql statement, returns the record, but with a small chance of a race condition @param sql: sql to execute @return: The last row inserted """ |
assert "update" in sql.lower(), 'This function requires an update statement, provided: {}'.format(sql)
cursor = CoyoteDb.execute_and_commit(sql, *args, **kwargs)
# now get that id
last_row_id = cursor.lastrowid
return last_row_id |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete(sql, *args, **kwargs):
"""Deletes and commits with an insert sql statement""" |
assert "delete" in sql.lower(), 'This function requires a delete statement, provided: {}'.format(sql)
CoyoteDb.execute_and_commit(sql, *args, **kwargs) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_object_from_dictionary_representation(dictionary, instance):
"""Given a dictionary and an object instance, will set all object attributes equal to the dictionary's keys and values. Assumes dictionary does not have any keys for which object does not have attributes @type dictionary: dict @param dictionary: Dictionary representation of the object @param instance: Object instance to populate @return: None """ |
for key, value in dictionary.iteritems():
if hasattr(instance, key):
setattr(instance, key, value)
return instance |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def format_time(time):
"""Formats a time to be Shapeways database-compatible @param time: Datetime or string object to format @rtype: str @return: Time formatted as a string """ |
# Handle time typing
try:
time = time.isoformat()
except AttributeError: # Not a datetime object
time = str(time)
time = parser.parse(time).strftime('%Y-%m-%d %H:%M:%S')
return time |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def format_date(date):
"""Formats a date to be Shapeways database-compatible @param date: Datetime or string object to format @rtype: str @return: Date formatted as a string """ |
# Handle time typing
try:
date = date.isoformat()
except AttributeError: # Not a datetime object
date = str(date)
date = parser.parse(date).strftime('%Y-%m-%d')
return date |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def visit(self, url=''):
""" Driver gets the provided url in the browser, returns True if successful url -- An absolute or relative url stored as a string """ |
def _visit(url):
if len(url) > 0 and url[0] == '/':
# url's first character is a forward slash; treat as relative path
path = url
full_url = self.driver.current_url
parsed_url = urlparse(full_url)
base_url = str(parsed_url.scheme) + '://' + str(parsed_url.netloc)
url = urljoin(base_url, path)
try:
return self.driver.get(url)
except TimeoutException:
if self.ignore_page_load_timeouts:
pass
else:
raise PageTimeoutException.PageTimeoutException(self, url)
return self.execute_and_handle_webdriver_exceptions(lambda: _visit(url)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_alert_present(self):
"""Tests if an alert is present @return: True if alert is present, False otherwise """ |
current_frame = None
try:
current_frame = self.driver.current_window_handle
a = self.driver.switch_to_alert()
a.text
except NoAlertPresentException:
# No alert
return False
except UnexpectedAlertPresentException:
# Alert exists
return True
finally:
if current_frame:
self.driver.switch_to_window(current_frame)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find(self, locator, find_all=False, search_object=None, force_find=False, exclude_invisible=False):
""" Attempts to locate an element, trying the number of times specified by the driver wrapper; Will throw a WebDriverWrapperException if no element is found @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string used to query the element @type find_all: bool @param find_all: set to True to locate all located elements as a list @type search_object: webdriverwrapper.WebElementWrapper @param force_find: If true will use javascript to find elements @type force_find: bool @param search_object: A WebDriver or WebElement object to call find_element(s)_by_xxxxx """ |
search_object = self.driver if search_object is None else search_object
attempts = 0
while attempts < self.find_attempts + 1:
if bool(force_find):
js_locator = self.locator_handler.parse_locator(locator)
if js_locator.By != 'css selector':
raise ValueError(
'You must use a css locator in order to force find an element; this was "{}"'.format(
js_locator))
elements = self.js_executor.execute_template_and_return_result(
'getElementsTemplate.js', variables={'selector': js_locator.value})
else:
elements = self.locator_handler.find_by_locator(search_object, locator, True)
# Save original elements found before applying filters to the list
all_elements = elements
# Check for only visible elements
visible_elements = elements
if exclude_invisible:
visible_elements = [element for element in all_elements if element.is_displayed()]
elements = visible_elements
if len(elements) > 0:
if find_all is True:
# return list of wrapped elements
for index in range(len(elements)):
elements[index] = WebElementWrapper.WebElementWrapper(self, locator, elements[index],
search_object=search_object)
return elements
elif find_all is False:
# return first element
return WebElementWrapper.WebElementWrapper(self, locator, elements[0], search_object=search_object)
else:
if attempts >= self.find_attempts:
if find_all is True: # returns an empty list if finding all elements
return []
else: # raise exception if attempting to find one element
error_message = "Unable to find element after {0} attempts with locator: {1}".format(
attempts,
locator
)
# Check if filters limited the results
if exclude_invisible and len(visible_elements) == 0 and len(all_elements) > 0:
error_message = "Elements found using locator {}, but none were visible".format(locator)
raise WebDriverWrapperException.WebDriverWrapperException(self, error_message)
else:
attempts += 1 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def _find_immediately(self, locator, search_object=None):
'''
Attempts to immediately find elements on the page without waiting
@type locator: webdriverwrapper.support.locator.Locator
@param locator: Locator object describing
@type search_object: webdriverwrapper.WebElementWrapper
@param search_object: Optional WebElement to start search with. If null, search will be on self.driver
@return: Single WebElemetnWrapper if find_all is False,
list of WebElementWrappers if find_all is True
'''
search_object = self.driver if search_object is None else search_object
elements = self.locator_handler.find_by_locator(search_object, locator, True)
return [WebElementWrapper.WebElementWrapper(self, locator, element) for element in elements] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def find_all(self, locator, search_object=None, force_find=False):
'''
Find all elements matching locator
@type locator: webdriverwrapper.support.locator.Locator
@param locator: Locator object describing
@rtype: list[WebElementWrapper]
@return: list of WebElementWrappers
'''
return self.find(locator=locator, find_all=True, search_object=search_object, force_find=force_find) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def find_by_dynamic_locator(self, template_locator, variables, find_all=False, search_object=None):
'''
Find with dynamic locator
@type template_locator: webdriverwrapper.support.locator.Locator
@param template_locator: Template locator w/ formatting bits to insert
@type variables: dict
@param variables: Dictionary of variable substitutions
@type find_all: bool
@param find_all: True to find all elements immediately, False for find single element only
@type search_object: webdriverwrapper.WebElementWrapper
@param search_object: Optional WebElement to start search with.
If null, search will be on self.driver
@rtype: webdriverwrapper.WebElementWrapper or list()
@return: Single WebElemetnWrapper if find_all is False,
list of WebElementWrappers if find_all is True
'''
template_variable_character = '%'
# raise an exception if user passed non-dictionary variables
if not isinstance(variables, dict):
raise TypeError('You must use a dictionary to populate locator variables')
# replace all variables that match the keys in 'variables' dict
locator = ""
for key in variables.keys():
locator = template_locator.replace(template_variable_character + key, variables[key])
return self.find(locator, find_all, search_object) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_present(self, locator, search_object=None):
""" Determines whether an element is present on the page, retrying once if unable to locate @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string used to query the element @type search_object: webdriverwrapper.WebElementWrapper @param search_object: Optional WebElement to start search with. If null, search will be on self.driver """ |
all_elements = self._find_immediately(locator, search_object=search_object)
if all_elements is not None and len(all_elements) > 0:
return True
else:
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_present_no_wait(self, locator):
""" Determines whether an element is present on the page with no wait @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string used to query the element """ |
# first attempt to locate the element
def execute():
'''
Generic function to execute wait
'''
return True if len(self.locator_handler.find_by_locator(self.driver, locator, True)) < 0 else False
return self.execute_and_handle_webdriver_exceptions(
execute, timeout=0, locator=locator, failure_message='Error running webdriver.find_all.') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_present(self, locator, timeout=None, failure_message='Timeout waiting for element to be present'):
""" Waits for an element to be present @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string to search for the element @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
timeout = timeout if timeout is not None else self.timeout
def wait():
'''
Wait function passed to executor
'''
element = WebDriverWait(self.driver, timeout).until(EC.presence_of_element_located(
(self.locator_handler.parse_locator(locator).By, self.locator_handler.parse_locator(locator).value)))
return WebElementWrapper.WebElementWrapper(self, locator, element)
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, failure_message=failure_message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_not_present(self, locator, timeout=None):
""" Waits for an element to no longer be present @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string to search for the element @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
# TODO: rethink about neg case with is_present and waiting too long
timeout = timeout if timeout is not None else self.timeout
this = self # for passing WebDriverWrapperReference to WebDriverWait
def wait():
'''
Wait function pasted to executor
'''
return WebDriverWait(self.driver, timeout).until(lambda d: not this.is_present(locator))
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, 'Timeout waiting for element not to be present') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_invisibility_of(self, locator, timeout=None):
""" Waits for an element to be invisible @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string to search for the element @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
timeout = timeout if timeout is not None else self.timeout
def wait():
'''
Wait function passed to executor
'''
element = WebDriverWait(self.driver, timeout).until(EC.invisibility_of_element_located(
(self.locator_handler.parse_locator(locator).By, self.locator_handler.parse_locator(locator).value)))
return WebElementWrapper.WebElementWrapper(self, locator, element)
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, 'Timeout waiting for element to be invisible') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_clickable(self, locator, timeout=None):
""" Waits for an element to be clickable @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string to search for the element @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
timeout = timeout if timeout is not None else self.timeout
def wait():
'''
Wait function passed to executor
'''
element = WebDriverWait(self.driver, timeout).until(EC.element_to_be_clickable(
(self.locator_handler.parse_locator(locator).By, self.locator_handler.parse_locator(locator).value)))
return WebElementWrapper.WebElementWrapper(self, locator, element)
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, 'Timeout waiting for element to be clickable') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_stale(self, locator, timeout=None):
""" Waits for an element to be stale in the DOM @type locator: webdriverwrapper.support.locator.Locator @param locator: the locator or css string to search for the element @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
timeout = timeout if timeout is not None else self.timeout
def wait():
'''
Wait function passed to executor
'''
element = WebDriverWait(self.driver, timeout).until(EC.staleness_of(
(self.locator_handler.parse_locator(locator).By, self.locator_handler.parse_locator(locator).value)))
return WebElementWrapper.WebElementWrapper(self, locator, element)
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, 'Timeout waiting for element to become stale') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_alert_is_present(self, timeout=None):
""" Waits for an alert to be present @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
timeout = timeout if timeout is not None else self.timeout
locator = None
def wait():
'''
Wait function passed to executor
'''
return WebDriverWait(self.driver, timeout).until(EC.alert_is_present())
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, 'Timeout waiting for alert to be present') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_text_is_not_empty(self, locator, timeout=None):
""" Waits for an element's text to not be empty @type locator: webdriverwrapper.support.locator.Locator @param locator: locator used to find element @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
timeout = timeout if timeout is not None else self.timeout
self.wait_for(locator) # first check that element exists
def wait():
'''
Wait function passed to executor
'''
WebDriverWait(self.driver, timeout).until(lambda d: len(self.find(locator).text()) > 0)
return self.find(locator)
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, locator, 'Timeout waiting for element to contain some text') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_jquery_requests_are_closed(self, timeout=None):
"""Waits for AJAX requests made through @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @return: None """ |
timeout = timeout if timeout is not None else self.timeout
def wait():
'''
Wait function passed to executor
'''
WebDriverWait(self.driver, timeout).until(
lambda d: self.js_executor.execute_template('isJqueryAjaxComplete', {}))
return True
return self.execute_and_handle_webdriver_exceptions(
wait, timeout, None, 'Timeout waiting for all jQuery AJAX requests to close') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_and_handle_webdriver_exceptions(self, function_to_execute, timeout=None, locator=None, failure_message=None):
""" Executor for wait functions @type function_to_execute: types.FunctionType @param function_to_execute: wait function specifying the type of wait @type timeout: int @param timeout: the maximum number of seconds the driver will wait before timing out @type locator: webdriverwrapper.support.locator.Locator @param locator: locator used to find element @type failure_message: str @param failure_message: message shown in exception if wait fails @rtype: webdriverwrapper.WebElementWrapper @return: Returns the element found """ |
logger = logging.getLogger(__name__)
try:
val = function_to_execute()
for cb in self.action_callbacks:
cb.__call__(self)
return val
except TimeoutException:
raise WebDriverTimeoutException.WebDriverTimeoutException(self, timeout, locator, failure_message)
except httplib.BadStatusLine, e:
logger.error('BadStatusLine error raised on WebDriver action (line: {}, args:{}, message: {})'.format(
e.line,
e.args,
e.message
))
raise
except httplib.CannotSendRequest:
logger.error('CannotSendRequest error raised on WebDriver action')
raise
except UnexpectedAlertPresentException:
# NOTE: handling alerts in this way expects that WebDriver does not dismiss unexpected alerts. That
# setting can be changed by modifying the unexpectedAlertBehaviour setting
msg = '<failed to parse message from alert>'
try:
a = self.driver.switch_to_alert()
msg = a.text
except Exception, e:
msg = '<error parsing alert due to {} (note: parsing ' \
'alert text expects "unexpectedAlertBehaviour" to be set to "ignore")>'.format(e)
logger.critical(msg)
finally:
logger.error('Unexpected alert raised on a WebDriver action; alert message was: {}'.format(msg))
raise UnexpectedAlertPresentException('Unexpected alert on page, alert message was: "{}"'.format(msg)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pause_and_wait_for_user(self, timeout=None, prompt_text='Click to resume (WebDriver is paused)'):
"""Injects a radio button into the page and waits for the user to click it; will raise an exception if the radio to resume is never checked @return: None """ |
timeout = timeout if timeout is not None else self.user_wait_timeout
# Set the browser state paused
self.paused = True
def check_user_ready(driver):
"""Polls for the user to be "ready" (meaning they checked the checkbox) and the driver to be unpaused.
If the checkbox is not displayed (e.g. user navigates the page), it will re-insert it into the page
@type driver: WebDriverWrapper
@param driver: Driver to execute
@return: True if user is ready, false if not
"""
if driver.paused:
if driver.is_user_ready():
# User indicated they are ready; free the browser lock
driver.paused = False
return True
else:
if not driver.is_present(Locator('css', '#webdriver-resume-radio', 'radio to unpause webdriver')):
# Display the prompt
pause_html = staticreader.read_html_file('webdriverpaused.html')\
.replace('\n', '')\
.replace('PROMPT_TEXT', prompt_text)
webdriver_style = staticreader.read_css_file('webdriverstyle.css').replace('\n', '')
# Insert the webdriver style
driver.js_executor.execute_template_and_return_result(
'injectCssTemplate.js',
{'css': webdriver_style})
# Insert the paused html
driver.js_executor.execute_template_and_return_result(
'injectHtmlTemplate.js',
{'selector': 'body', 'html': pause_html})
return False
self.wait_until(
lambda: check_user_ready(self),
timeout=timeout,
failure_message='Webdriver actions were paused but did not receive the command to continue. '
'You must click the on-screen message to resume.'
)
# Remove all injected elements
self.js_executor.execute_template_and_return_result(
'deleteElementsTemplate.js',
{'selector': '.webdriver-injected'}
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_browser_log(self, levels=None):
"""Gets the console log of the browser @type levels: @return: List of browser log entries """ |
logs = self.driver.get_log('browser')
self.browser_logs += logs
if levels is not None:
logs = [entry for entry in logs if entry.get(u'level') in levels]
return logs |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def quit(self):
"""Close driver and kill all associated displays """ |
# Kill the driver
def _quit():
try:
self.driver.quit()
except Exception, err_driver:
os.kill(self.driver_pid, signal.SIGKILL)
raise
finally:
# Kill the display for this driver window
try:
if self.display:
self.display.stop()
except Exception, err_display:
os.kill(self.display_pid, signal.SIGKILL)
raise
return self.execute_and_handle_webdriver_exceptions(_quit) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def visit(self, url=''):
"""Visit the url, checking for rr errors in the response @param url: URL @return: Visit result """ |
result = super(CoyoteDriver, self).visit(url)
source = self.page_source()
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_config_vars(target_config, source_config):
"""Loads all attributes from source config into target config @type target_config: TestRunConfigManager @param target_config: Config to dump variables into @type source_config: TestRunConfigManager @param source_config: The other config @return: True """ |
# Overwrite all attributes in config with new config
for attr in dir(source_config):
# skip all private class attrs
if attr.startswith('_'):
continue
val = getattr(source_config, attr)
if val is not None:
setattr(target_config, attr, val) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run_parallel(*functions):
"""Runs a series of functions in parallel. Return values are ordered by the order in which their functions were passed. If an exception is raised within one of the processes, that exception will be caught at the process level and raised by the parent process as an ErrorInProcessException, which will track all errors raised in all processes. You can catch the exception raised for more details into the process exceptions: @param functions: The functions to run specified as individual arguments @return: List of results for those functions. Unpacking is recommended if you do not need to iterate over the results as it enforces the number of functions you pass in. @raise: ErrorInProcessException """ |
def target(fn):
def wrapped(results_queue, error_queue, index):
result = None
try:
result = fn()
except Exception, e: # Swallow errors or else the process will hang
error_queue.put(e)
warnings.warn('Exception raised in parallel threads: {}'.format(e))
results_queue.put((index, result))
return wrapped
errors = Queue()
queue = Queue()
jobs = list()
for i, function in enumerate(functions):
jobs.append(Process(target=target(function), args=(queue, errors, i)))
[job.start() for job in jobs]
[job.join() for job in jobs]
# Get the results in the queue and put them back in the order in which the function was specified in the args
results = [queue.get() for _ in jobs]
results = sorted(results, key=lambda x: x[0])
if not errors.empty():
error_list = list()
while not errors.empty():
error_list.append(errors.get())
raise ErrorInProcessException('Exceptions raised in parallel threads: {}'.format(error_list), errors=error_list)
return [r[1] for r in results] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def copy_and_update(dictionary, update):
"""Returns an updated copy of the dictionary without modifying the original""" |
newdict = dictionary.copy()
newdict.update(update)
return newdict |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_static_directory():
"""Retrieves the full path of the static directory @return: Full path of the static directory """ |
directory = templates_dir = os.path.join(os.path.dirname(__file__), 'static')
return directory |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_html_file(filename):
"""Reads the contents of an html file in the css directory @return: Contents of the specified file """ |
with open(os.path.join(get_static_directory(), 'html/{filename}'.format(filename=filename))) as f:
contents = f.read()
return contents |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse_locator(locator):
""" Parses a valid selenium By and value from a locator; returns as a named tuple with properties 'By' and 'value' locator -- a valid element locator or css string """ |
# handle backwards compatibility to support new Locator class
if isinstance(locator, loc.Locator):
locator = '{by}={locator}'.format(by=locator.by, locator=locator.locator)
locator_tuple = namedtuple('Locator', 'By value')
if locator.count('=') > 0 and locator.count('css=') < 1:
by = locator[:locator.find('=')].replace('_', ' ')
value = locator[locator.find('=')+1:]
return locator_tuple(by, value)
else: # assume default is css selector
value = locator[locator.find('=')+1:]
return locator_tuple('css selector', value) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def spin_assert(self, assertion, failure_message='Failed Assertion', timeout=None):
""" Asserts that assertion function passed to it will return True, trying every 'step' seconds until 'timeout' seconds have passed. """ |
timeout = self.timeout if timeout is None else timeout
time_spent = 0
while time_spent < timeout:
try:
assert assertion() is True
return True
except AssertionError:
pass
sleep(self.step)
time_spent += 1
raise WebDriverAssertionException.WebDriverAssertionException(self.driver_wrapper, failure_message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def webdriver_assert(self, assertion, failure_message='Failed Assertion'):
""" Assert the assertion, but throw a WebDriverAssertionException if assertion fails """ |
try:
assert assertion() is True
except AssertionError:
raise WebDriverAssertionException.WebDriverAssertionException(self.driver_wrapper, failure_message)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_true(self, value, failure_message='Expected value to be True, was: {}'):
""" Asserts that a value is true @type value: bool @param value: value to test for True """ |
assertion = lambda: bool(value)
self.webdriver_assert(assertion, unicode(failure_message).format(value)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_equals(self, actual_val, expected_val, failure_message='Expected values to be equal: "{}" and "{}"'):
""" Calls smart_assert, but creates its own assertion closure using the expected and provided values with the '==' operator """ |
assertion = lambda: expected_val == actual_val
self.webdriver_assert(assertion, unicode(failure_message).format(actual_val, expected_val)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_numbers_almost_equal(self, actual_val, expected_val, allowed_delta=0.0001, failure_message='Expected numbers to be within {} of each other: "{}" and "{}"'):
""" Asserts that two numbers are within an allowed delta of each other """ |
assertion = lambda: abs(expected_val - actual_val) <= allowed_delta
self.webdriver_assert(assertion, unicode(failure_message).format(allowed_delta, actual_val, expected_val)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_not_equal(self, actual_val, unexpected_val, failure_message='Expected values to differ: "{}" and "{}"'):
""" Calls smart_assert, but creates its own assertion closure using the expected and provided values with the '!=' operator """ |
assertion = lambda: unexpected_val != actual_val
self.webdriver_assert(assertion, unicode(failure_message).format(actual_val, unexpected_val)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_is(self, actual_val, expected_type, failure_message='Expected type to be "{1}," but was "{0}"'):
""" Calls smart_assert, but creates its own assertion closure using the expected and provided values with the 'is' operator """ |
assertion = lambda: expected_type is actual_val
self.webdriver_assert(assertion, unicode(failure_message).format(actual_val, expected_type)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_is_not(self, actual_val, unexpected_type, failure_message='Expected type not to be "{1}," but was "{0}"'):
""" Calls smart_assert, but creates its own assertion closure using the expected and provided values with the 'is not' operator """ |
assertion = lambda: unexpected_type is not actual_val
self.webdriver_assert(assertion, unicode(failure_message).format(actual_val, unexpected_type)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_in(self, actual_collection_or_string, expected_value, failure_message='Expected "{1}" to be in "{0}"'):
""" Calls smart_assert, but creates its own assertion closure using the expected and provided values with the 'in' operator """ |
assertion = lambda: expected_value in actual_collection_or_string
self.webdriver_assert(assertion, unicode(failure_message).format(actual_collection_or_string, expected_value)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_not_in(self, actual_collection_or_string, unexpected_value, failure_message='Expected "{1}" not to be in "{0}"'):
""" Calls smart_assert, but creates its own assertion closure using the expected and provided values with the 'not in' operator """ |
assertion = lambda: unexpected_value not in actual_collection_or_string
self.webdriver_assert(assertion, unicode(failure_message).format(actual_collection_or_string, unexpected_value)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_page_source_contains(self, expected_value, failure_message='Expected page source to contain: "{}"'):
""" Asserts that the page source contains the string passed in expected_value """ |
assertion = lambda: expected_value in self.driver_wrapper.page_source()
self.webdriver_assert(assertion, unicode(failure_message).format(expected_value)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def assert_subset(self, subset, superset, failure_message='Expected collection "{}" to be a subset of "{}'):
""" Asserts that a superset contains all elements of a subset """ |
assertion = lambda: set(subset).issubset(set(superset))
failure_message = unicode(failure_message).format(superset, subset)
self.webdriver_assert(assertion, failure_message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def clear(self):
""" Clears the field represented by this element @rtype: WebElementWrapper @return: Returns itself """ |
def clear_element():
"""
Wrapper to clear element
"""
return self.element.clear()
self.execute_and_handle_webelement_exceptions(clear_element, 'clear')
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete_content(self, max_chars=100):
""" Deletes content in the input field by repeatedly typing HOME, then DELETE @rtype: WebElementWrapper @return: Returns itself """ |
def delete_content_element():
chars_deleted = 0
while len(self.get_attribute('value')) > 0 and chars_deleted < max_chars:
self.click()
self.send_keys(Keys.HOME)
self.send_keys(Keys.DELETE)
chars_deleted += 1
self.execute_and_handle_webelement_exceptions(delete_content_element, 'delete input contents')
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def click(self, force_click=False):
""" Clicks the element @type force_click: bool @param force_click: force a click on the element using javascript, skipping webdriver @rtype: WebElementWrapper @return: Returns itself """ |
js_executor = self.driver_wrapper.js_executor
def click_element():
"""
Wrapper to call click
"""
return self.element.click()
def force_click_element():
"""
Javascript wrapper to force_click the element
"""
js_executor.execute_template('clickElementTemplate', {}, self.element)
return True
if force_click:
self.execute_and_handle_webelement_exceptions(force_click_element, 'click element by javascript')
else:
self.execute_and_handle_webelement_exceptions(click_element, 'click')
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_value(self):
"""Gets the value of a select or input element @rtype: str @return: The value of the element @raise: ValueError if element is not of type input or select, or has multiple selected options """ |
def get_element_value():
if self.tag_name() == 'input':
return self.get_attribute('value')
elif self.tag_name() == 'select':
selected_options = self.element.all_selected_options
if len(selected_options) > 1:
raise ValueError(
'Select {} has multiple selected options, only one selected '
'option is valid for this method'.format(self)
)
return selected_options[0].get_attribute('value')
else:
raise ValueError('Can not get the value of elements or type "{}"'.format(self.tag_name()))
return self.execute_and_handle_webelement_exceptions(get_element_value, name_of_action='get value') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_attribute(self, name):
""" Retrieves specified attribute from WebElement @type name: str @param name: Attribute to retrieve @rtype: str @return: String representation of the attribute """ |
def get_attribute_element():
"""
Wrapper to retrieve element
"""
return self.element.get_attribute(name)
return self.execute_and_handle_webelement_exceptions(get_attribute_element, 'get attribute "' + str(name) + '"') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def submit(self):
""" Submit a webe element @rtype: WebElementWrapper @return: Self """ |
def submit_element():
"""
Wrapper to submit element
"""
return self.element.submit()
self.execute_and_handle_webelement_exceptions(submit_element, 'send keys')
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def value_of_css_property(self, property_name):
""" Get value of CSS property for element @rtype: str @return: value of CSS property """ |
def value_of_css_property_element():
"""
Wrapper to get css property
"""
return self.element.value_of_css_property(property_name)
return self.execute_and_handle_webelement_exceptions(value_of_css_property_element, 'get css property "' +
str(property_name) + '"') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def has_class(self, classname):
"""Test if an element has a specific classname @type classname: str @param classname: Classname to test for; cannot contain spaces @rtype: bool @return: True if classname exists; false otherwise """ |
def element_has_class():
"""Wrapper to test if element has a class"""
pattern = re.compile('(\s|^){classname}(\s|$)'.format(classname=classname))
classes = self.element.get_attribute('class')
matches = re.search(pattern, classes)
if matches is not None:
return True
return False
return self.execute_and_handle_webelement_exceptions(
element_has_class,
'check for element class "{}"'.format(classname)
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def text(self, force_get=False):
""" Get the text of the element @rtype: str @return: Text of the element """ |
def text_element():
"""
Wrapper to get text of element
"""
return self.element.text
def force_text_element():
"""Get text by javascript"""
return self.driver_wrapper.js_executor.execute_template_and_return_result(
'getElementText.js', {}, self.element
)
if force_get:
return self.execute_and_handle_webelement_exceptions(force_text_element, 'get text by javascript')
else:
return self.execute_and_handle_webelement_exceptions(text_element, 'get text') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def highlight(self):
""" Draws a dotted red box around the wrapped element using javascript @rtype: WebElementWrapper @return: Self """ |
js_executor = self.driver_wrapper.js_executor
def highlight_element():
"""
Wrapper to highlight elements
"""
location = self.element.location
size = self.element.size
js_executor.execute_template('elementHighlighterTemplate', {
'x': str(location['x']),
'y': str(location['y']),
'width': str(size['width']),
'height': str(size['height'])})
return True
self.execute_and_handle_webelement_exceptions(highlight_element, 'highlight')
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_attribute(self, name, value):
"""Sets the attribute of the element to a specified value @type name: str @param name: the name of the attribute @type value: str @param value: the attribute of the value """ |
js_executor = self.driver_wrapper.js_executor
def set_attribute_element():
"""
Wrapper to set attribute
"""
js_executor.execute_template('setAttributeTemplate', {
'attribute_name': str(name),
'attribute_value': str(value)}, self.element)
return True
self.execute_and_handle_webelement_exceptions(set_attribute_element,
'set attribute "' + str(name) + '" to "' + str(value) + '"')
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def select_option(self, value=None, text=None, index=None):
""" Selects an option by value, text, or index. You must name the parameter @type value: str @param value: the value of the option @type text: str @param text: the option's visible text @type index: int @param index: the zero-based index of the option @rtype: WebElementWrapper @return: self """ |
def do_select():
"""
Perform selection
"""
return self.set_select('select', value, text, index)
return self.execute_and_handle_webelement_exceptions(do_select, 'select option') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def deselect_option(self, value=None, text=None, index=None):
""" De-selects an option by value, text, or index. You must name the parameter @type value: str @param value: the value of the option @type text: str @param text: the option's visible text @type index: int @param index: the zero-based index of the option @rtype: WebElementWrapper @return: self """ |
def do_deselect():
"""
Perform selection
"""
return self.set_select('deselect', value, text, index)
return self.execute_and_handle_webelement_exceptions(do_deselect, 'deselect option') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_select(self, select_or_deselect = 'select', value=None, text=None, index=None):
""" Private method used by select methods @type select_or_deselect: str @param select_or_deselect: Should I select or deselect the element @type value: str @type value: Value to be selected @type text: str @type text: Text to be selected @type index: int @type index: index to be selected @rtype: WebElementWrapper @return: Self """ |
# TODO: raise exception if element is not select element
if select_or_deselect is 'select':
if value is not None:
Select(self.element).select_by_value(value)
elif text is not None:
Select(self.element).select_by_visible_text(text)
elif index is not None:
Select(self.element).select_by_index(index)
elif select_or_deselect is 'deselect':
if value is not None:
Select(self.element).deselect_by_value(value)
elif text is not None:
Select(self.element).deselect_by_visible_text(text)
elif index is not None:
Select(self.element).deselect_by_index(index)
elif select_or_deselect is 'deselect all':
Select(self.element).deselect_all()
return self |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def checkbox_check(self, force_check=False):
""" Wrapper to check a checkbox """ |
if not self.get_attribute('checked'):
self.click(force_click=force_check) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def checkbox_uncheck(self, force_check=False):
""" Wrapper to uncheck a checkbox """ |
if self.get_attribute('checked'):
self.click(force_click=force_check) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def hover(self):
""" Hovers the element """ |
def do_hover():
"""
Perform hover
"""
ActionChains(self.driver_wrapper.driver).move_to_element(self.element).perform()
return self.execute_and_handle_webelement_exceptions(do_hover, 'hover') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find(self, locator, find_all=False, search_object=None, exclude_invisible=None, *args, **kwargs):
""" Find wrapper, invokes webDriverWrapper find with the current element as the search object @type locator: webdriverwrapper.support.locator.Locator @param locator: locator used in search @type find_all: bool @param find_all: should I find all elements, or just one? @type search_object: WebElementWrapper @param search_object: Used to override the starting point of the driver search @rtype: WebElementWrapper or list[WebElementWrapper] @return: Either a single WebElementWrapper, or a list of WebElementWrappers """ |
search_object = self.element if search_object is None else search_object
return self.driver_wrapper.find(
locator,
find_all,
search_object=search_object,
exclude_invisible=exclude_invisible
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_once(self, locator):
""" Find wrapper to run a single find @type locator: webdriverwrapper.support.locator.Locator @param locator: locator used in search @type find_all: bool @param find_all: should I find all elements, or just one? @rtype: WebElementWrapper or list[WebElementWrapper] @return: Either a single WebElementWrapper, or a list of WebElementWrappers """ |
params = []
params.append(self.driver_wrapper.find_attempts)
params.append(self.driver_wrapper.implicit_wait)
self.driver_wrapper.find_attempts = 1
self.driver_wrapper.implicit_wait = 0
result = self.driver_wrapper._find_immediately(locator, self.element)
# restore the original params
self.driver_wrapper.implicit_wait = params.pop()
self.driver_wrapper.find_attempts = params.pop()
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def find_all(self, locator):
""" Find wrapper, finds all elements @type locator: webdriverwrapper.support.locator.Locator @param locator: locator used in search @rtype: list @return: A list of WebElementWrappers """ |
return self.driver_wrapper.find(locator, True, self.element) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_present(self, locator):
""" Tests to see if an element is present @type locator: webdriverwrapper.support.locator.Locator @param locator: locator used in search @rtype: bool @return: True if present, False if not present """ |
return self.driver_wrapper.is_present(locator, search_object=self.element) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wait_until_stale(self, timeout=None):
""" Waits for the element to go stale in the DOM @type timeout: int @param timeout: override for default timeout @rtype: WebElementWrapper @return: Self """ |
timeout = timeout if timeout is not None else self.driver_wrapper.timeout
def wait():
"""
Wrapper to wait for element to be stale
"""
WebDriverWait(self.driver, timeout).until(EC.staleness_of(self.element))
return self
return self.execute_and_handle_webelement_exceptions(wait, 'wait for staleness') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_and_handle_webelement_exceptions(self, function_to_execute, name_of_action):
""" Private method to be called by other methods to handle common WebDriverExceptions or throw a custom exception @type function_to_execute: types.FunctionType @param function_to_execute: A function containing some webdriver calls @type name_of_action: str @param name_of_action: The name of the action you are trying to perform for building the error message """ |
if self.element is not None:
attempts = 0
while attempts < self.driver_wrapper.find_attempts+1:
try:
attempts = attempts + 1
val = function_to_execute()
for cb in self.driver_wrapper.action_callbacks:
cb.__call__(self.driver_wrapper)
return val
except StaleElementReferenceException:
self.element = self.driver_wrapper.find(self.locator, search_object=self.search_object).element
except ElementNotVisibleException:
raise WebElementNotVisibleException.WebElementNotVisibleException(self,
'WebElement with locator: {} was not visible, so could not {}'.format(
self.locator, name_of_action))
except MoveTargetOutOfBoundsException:
raise WebElementNotVisibleException.WebElementNotVisibleException(self,
'WebElement with locator: {} was out of window, so could not {}'.format(
self.locator, name_of_action))
except TimeoutException:
raise WebDriverTimeoutException.WebDriverTimeoutException(
self.driver_wrapper, timeout=self.driver_wrapper.timeout, locator=self.locator,
msg='Timeout on action: {}'.format(name_of_action))
except UnexpectedAlertPresentException:
msg = 'failed to parse message from alert'
try:
a = self.driver.switch_to_alert()
msg = a.text
finally:
raise UnexpectedAlertPresentException('Unexpected alert on page: {}'.format(msg))
except BadStatusLine, e:
logging.getLogger(__name__).error('{} error raised on action: {} (line: {}, args:{}, message: {})'.format(
BadStatusLine.__class__.__name__,
name_of_action,
e.line,
e.args,
e.message
))
raise
raise StaleWebElementException.StaleWebElementException(self,
'Cannot {} element with locator: {}; the reference to the WebElement was stale ({} attempts)'
.format(name_of_action, self.locator, self.driver_wrapper.find_attempts))
else:
raise WebElementDoesNotExist.WebElementDoesNotExist(self,
'Cannot {} element with locator: {}; it does not exist'.format(name_of_action, self.locator)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def request(self, uri, method=GET, headers=None, cookies=None, params=None, data=None, post_files=None,**kwargs):
"""Makes a request using requests @param uri: The uri to send request @param method: Method to use to send request @param headers: Any headers to send with request @param cookies: Request cookies (in addition to session cookies) @param params: Request parameters @param data: Request data @param kwargs: other options to pass to underlying request @rtype: requests.Response @return: The response """ |
coyote_args = {
'headers': headers,
'cookies': cookies,
'params': params,
'files': post_files,
'data': data,
'verify': self.verify_certificates,
}
coyote_args.update(kwargs)
if method == self.POST:
response = self.session.post(uri, **coyote_args)
elif method == self.PUT:
response = self.session.put(uri, **coyote_args)
elif method == self.PATCH:
response = self.session.patch(uri, **coyote_args)
elif method == self.DELETE:
response = self.session.delete(uri, **coyote_args)
else: # Default to GET
response = self.session.get(uri, **coyote_args)
self.responses.append(response)
while len(self.responses) > self.max_response_history:
self.responses.popleft()
return response |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_urls(urls, allowed_response_codes=None):
"""Validates that a list of urls can be opened and each responds with an allowed response code urls -- the list of urls to ping allowed_response_codes -- a list of response codes that the validator will ignore """ |
for url in urls:
validate_url(url, allowed_response_codes=allowed_response_codes)
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def new_driver(browser_name, *args, **kwargs):
"""Instantiates a new WebDriver instance, determining class by environment variables """ |
if browser_name == FIREFOX:
return webdriver.Firefox(*args, **kwargs)
# elif options['local'] and options['browser_name'] == CHROME:
# return webdriver.Chrome(*args, **kwargs)
#
# elif options['local'] and options['browser_name'] == IE:
# return webdriver.Ie(*args, **kwargs)
#
# elif options['local'] and options['browser_name'] == OPERA:
# return webdriver.Opera(*args, **kwargs)
elif browser_name == PHANTOMJS:
executable_path = os.path.join(os.path.dirname(__file__), 'phantomjs/executable/phantomjs_64bit')
driver = webdriver.PhantomJS(executable_path=executable_path, **kwargs)
driver.set_window_size(1280, 800) # Set a default because phantom needs it
return driver
else: # remote
driver = webdriver.Remote(*args, **kwargs)
return driver |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def encode_collection(collection, encoding='utf-8'):
"""Encodes all the string keys and values in a collection with specified encoding""" |
if isinstance(collection, dict):
return dict((encode_collection(key), encode_collection(value)) for key, value in collection.iteritems())
elif isinstance(collection, list):
return [encode_collection(element) for element in input]
elif isinstance(collection, unicode):
return collection.encode(encoding)
else:
return collection |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_delimited_string_from_list(_list, delimiter=', ', wrap_values_with_char=None, wrap_strings_with_char=None):
"""Given a list, returns a string representation of that list with specified delimiter and optional string chars _list -- the list or tuple to stringify delimiter -- the the character to seperate all values wrap_values_with_char -- if specified, will wrap all values in list with this character in the representation wrap_strings_with_char -- if specified, will wrap only values of type str with this character in the representation """ |
if wrap_values_with_char is not None:
return delimiter.join('{wrapper}{val}{wrapper}'.format(
val=v,
wrapper=wrap_values_with_char
) for v in _list)
elif wrap_strings_with_char is not None:
return delimiter.join(str(v) if not isinstance(v, str) else '{wrapper}{val}{wrapper}'.format(
val=v,
wrapper=wrap_strings_with_char
) for v in _list)
else:
return delimiter.join(str(v) for v in _list) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_script(self, string, args=None):
""" Execute script passed in to function @type string: str @value string: Script to execute @type args: dict @value args: Dictionary representing command line args @rtype: int @rtype: response code """ |
result = None
try:
result = self.driver_wrapper.driver.execute_script(string, args)
return result
except WebDriverException:
if result is not None:
message = 'Returned: ' + str(result)
else:
message = "No message. Check your Javascript source: {}".format(string)
raise WebDriverJavascriptException.WebDriverJavascriptException(self.driver_wrapper, message) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_template(self, template_name, variables, args=None):
""" Execute script from a template @type template_name: str @value template_name: Script template to implement @type args: dict @value args: Dictionary representing command line args @rtype: bool @rtype: Success or failure """ |
js_text = self.build_js_from_template(template_name, variables)
try:
self.execute_script(js_text, args)
except WebDriverException:
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_template_and_return_result(self, template_name, variables, args=None):
""" Execute script from a template and return result @type template_name: str @value template_name: Script template to implement @type variables: dict @value variables: Dictionary representing template construction args @type args: dict @value args: Dictionary representing command line args @rtype: int @rtype: exit code """ |
js_text = self.build_js_from_template(template_name, variables)
return self.execute_script(js_text, args) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def build_js_from_template(self, template_file, variables):
""" Build a JS script from a template and args @type template_file: str @param template_file: Script template to implement; can be the name of a built-in script or full filepath to a js file that contains the script. E.g. 'clickElementTemplate.js', 'clickElementTemplate', and '/path/to/custom/template/script.js' are all acceptable @type variables: dict @param variables: Dictionary representing template construction args @rtype: int @rtype: exit code """ |
template_variable_character = '%'
# raise an exception if user passed non-dictionary variables
if not isinstance(variables, dict):
raise TypeError('You must use a dictionary to populate variables in a javascript template')
# This filename is not a full file, attempt to locate the file in built-in templates
if not os.path.isfile(template_file):
# append the .js extension if not included
if '.js' not in template_file:
template_file += '.js'
# find the template and read the text into a string variable
templates_dir = os.path.join(os.path.dirname(__file__), 'jsTemplates')
template_full_path = os.path.join(templates_dir, template_file)
# The filename specified should be the full path
else:
template_full_path = template_file
# Ensure that the file exists
if not os.path.isfile(template_full_path):
raise ValueError('File "{}" was not found; you must specify the name of a built-in javascript template '
'or the full filepath of a custom template'.format(template_full_path))
try:
js_text = open(template_full_path).read()
except IOError:
raise IOError('The template was not found or did not have read permissions: {}'.format(template_full_path))
# replace all variables that match the keys in 'variables' dict
for key in variables.keys():
# double escape single and double quotes after variable replacement
if hasattr(variables[key], 'replace'):
variables[key] = variables[key].replace("'", "\\'")
variables[key] = variables[key].replace('"', '\\"')
else: # variable is not a string
variables[key] = str(variables[key])
js_text = js_text.replace(template_variable_character + key, variables[key])
return js_text |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.