input stringlengths 11 7.65k | target stringlengths 22 8.26k |
|---|---|
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def on_random_range_max_changed(self):
self.ui.spinBoxRandomMinimum.setMaximum(self.ui.spinBoxRandomMaximum.value() - 1) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def on_btn_add_fuzzing_values_clicked(self):
if self.ui.comboBoxStrategy.currentIndex() == 0:
self.__add_fuzzing_range()
elif self.ui.comboBoxStrategy.currentIndex() == 1:
self.__add_fuzzing_boundaries()
elif self.ui.comboBoxStrategy.currentIndex() == 2:
self.... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def __add_fuzzing_range(self):
start = self.ui.sBAddRangeStart.value()
end = self.ui.sBAddRangeEnd.value()
step = self.ui.sBAddRangeStep.value()
self.fuzz_table_model.add_range(start, end + 1, step) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def __add_fuzzing_boundaries(self):
lower_bound = -1
if self.ui.spinBoxLowerBound.isEnabled():
lower_bound = self.ui.spinBoxLowerBound.value()
upper_bound = -1
if self.ui.spinBoxUpperBound.isEnabled():
upper_bound = self.ui.spinBoxUpperBound.value()
num_... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def __add_random_fuzzing_values(self):
n = self.ui.spinBoxNumberRandom.value()
minimum = self.ui.spinBoxRandomMinimum.value()
maximum = self.ui.spinBoxRandomMaximum.value()
self.fuzz_table_model.add_random(n, minimum, maximum) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def remove_duplicates(self):
if self.ui.chkBRemoveDuplicates.isChecked():
for lbl in self.message.message_type:
seq = lbl.fuzz_values[:]
seen = set()
add_seen = seen.add
lbl.fuzz_values = [l for l in seq if not (l in seen or add_seen(l)... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def set_current_label_name(self):
self.current_label.name = self.ui.comboBoxFuzzingLabel.currentText()
self.ui.comboBoxFuzzingLabel.setItemText(self.ui.comboBoxFuzzingLabel.currentIndex(), self.current_label.name) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def on_fuzz_msg_changed(self, index: int):
self.ui.comboBoxFuzzingLabel.setDisabled(False)
sel_label_ind = self.ui.comboBoxFuzzingLabel.currentIndex()
self.ui.comboBoxFuzzingLabel.blockSignals(True)
self.ui.comboBoxFuzzingLabel.clear()
if len(self.message.message_type) == 0:
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def echo_server(loop, address, unix):
if unix:
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
else:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(address)
sock.listen(5)
sock.setbl... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def echo_client(loop, client):
try:
client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
with client:
while True:
data = await loop.sock_recv(client, 1000000)
if not data:
break
await... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def echo_client_streams(reader, writer):
sock = writer.get_extra_info('socket')
try:
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
except (OSError, NameError):
pass
if PRINT:
print('Connection from', sock.getpeername())
while True:
data = await read... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def connection_made(self, transport):
self.transport = transport |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def connection_lost(self, exc):
self.transport = None |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def data_received(self, data):
self.transport.write(data) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def connection_made(self, transport):
self.transport = transport
# Here the buffer is intended to be copied, so that the outgoing buffer
# won't be wrongly updated by next read
self.buffer = bytearray(256 * 1024) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def get_buffer(self, sizehint):
return self.buffer |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def buffer_updated(self, nbytes):
self.transport.write(self.buffer[:nbytes]) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def print_debug(loop):
while True:
print(chr(27) + "[2J") # clear screen
loop.print_debug_info()
await asyncio.sleep(0.5) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_error_on_wrong_value_for_consumed_capacity():
resource = boto3.resource("dynamodb", region_name="ap-northeast-3")
client = boto3.client("dynamodb", region_name="ap-northeast-3")
client.create_table(
TableName="jobs",
KeySchema=[{"AttributeName": "job_id", "KeyType": "HASH"}],
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def index(self, request):
queryset = Condition.objects.select_related('source', 'target_option')
serializer = ConditionIndexSerializer(queryset, many=True)
return Response(serializer.data) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_consumed_capacity_get_unknown_item():
conn = boto3.client("dynamodb", region_name="us-east-1")
conn.create_table(
TableName="test_table",
KeySchema=[{"AttributeName": "u", "KeyType": "HASH"}],
AttributeDefinitions=[{"AttributeName": "u", "AttributeType": "S"}],
BillingMo... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def export(self, request):
serializer = ConditionExportSerializer(self.get_queryset(), many=True)
xml = ConditionRenderer().render(serializer.data)
return XMLResponse(xml, name='conditions') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_only_return_consumed_capacity_when_required(
capacity, should_have_capacity, should_have_table
):
resource = boto3.resource("dynamodb", region_name="ap-northeast-3")
client = boto3.client("dynamodb", region_name="ap-northeast-3")
client.create_table(
TableName="jobs",
KeySchema=... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def detail_export(self, request, pk=None):
serializer = ConditionExportSerializer(self.get_object())
xml = ConditionRenderer().render([serializer.data])
return XMLResponse(xml, name=self.get_object().key) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def __init__(self, translations_path, domain_name: str):
super().__init__()
self.update_types = self.process_update_types()
self.path = translations_path
self.domain = domain_name
self.translations = self.find_translations() |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def opengl_lamp_buttons(column, lamp):
split = column.row()
split.prop(lamp, "use", text="", icon='OUTLINER_OB_LAMP' if lamp.use else 'LAMP_DATA')
col = split.column()
col.active = lamp.use
row = col.row()
row.label(text="Diffuse:")
row.prop(lamp, "diffuse_color", text="")
row = col.ro... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def available_translations(self):
return list(self.translations) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
layout.template_header()
userpref = context.user_preferences
layout.operator_context = 'EXEC_AREA'
layout.operator("wm.save_userpref")
layout.operator_context = 'INVOKE_DEFAULT'
if userpref.active_section == 'INPU... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def gettext(self, text: str, lang: str = None):
"""
Singular translations
"""
if lang is None:
lang = self.context_lang.get()
if lang not in self.translations:
return text
translator = self.translations[lang]
return translator.gettext(te... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
userpref = context.user_preferences
layout.prop(userpref, "active_section", expand=True) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def ngettext(self, singular: str, plural: str, lang: str = None, n=1):
"""
Plural translations
"""
if lang is None:
lang = self.context_lang.get()
if lang not in self.translations:
if n == 1:
return singular
return plural
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
self.layout.operator("wm.appconfig_default", text="Blender (default)")
# now draw the presets
Menu.draw_preset(self, context) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def lazy_gettext(self, text: str, lang: str = None):
if not babel_imported:
raise RuntimeError('babel module is not imported. Check that you installed it.')
return LazyProxy(self.gettext, text, lang, enable_cache=False) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
split = layout.split()
row = split.row()
row.label("")
row = split.row()
row.label("Interaction:")
text = bpy.path.display_name(context.window_manager.keyconfigs.active.name)
if not text:
text = "... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def lazy_ngettext(self, singular: str, plural: str, lang: str = None, n=1):
if not babel_imported:
raise RuntimeError('babel module is not imported. Check that you installed it.')
return LazyProxy(self.ngettext, singular, plural, lang, n, enable_cache=False) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def get_user_language(self, obj):
"""
You need to override this method and return user language
"""
raise NotImplementedError |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'INTERFACE') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def process_update_types(self) -> list:
"""
You need to override this method and return any update types which you want to be processed
"""
raise NotImplementedError |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
import sys
layout = self.layout
userpref = context.user_preferences
view = userpref.view
row = layout.row()
col = row.column()
col.label(text="Display:")
col.prop(view, "show_tooltips")
col.prop(view, "show_tooltips_pyth... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def pre_process(self, message, data):
"""
context language variable will be set each time when update from 'process_update_types' comes
value is the result of 'get_user_language' method
"""
self.context_lang.set(await self.get_user_language(obj=message)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'EDITING') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | async def post_process(self, message, data, exception):
pass |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
userpref = context.user_preferences
edit = userpref.edit
row = layout.row()
col = row.column()
col.label(text="Link Materials To:")
col.prop(edit, "material_link", text="")
col.separator()
col.separ... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'SYSTEM') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
import sys
layout = self.layout
userpref = context.user_preferences
system = userpref.system
split = layout.split()
# 1. Column
column = split.column()
colsplit = column.split(percentage=0.85)
col = colsplit.column()
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def theme_generic_recurse(data):
col.label(data.rna_type.name)
row = col.row()
subsplit = row.split(percentage=0.95)
padding1 = subsplit.split(percentage=0.15)
padding1.column()
subsplit = row.split(percentage=0.85)
padding2 = subspl... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def _theme_widget_style(layout, widget_style):
row = layout.row()
subsplit = row.split(percentage=0.95)
padding = subsplit.split(percentage=0.15)
colsub = padding.column()
colsub = padding.column()
colsub.row().prop(widget_style, "outline")
colsub.row().prop(wi... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def _ui_font_style(layout, font_style):
split = layout.split()
col = split.column()
col.label(text="Kerning Style:")
col.row().prop(font_style, "font_kerning_style", expand=True)
col.prop(font_style, "points")
col = split.column()
col.label(text="Shadow Offset:... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'THEMES') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
theme = context.user_preferences.themes[0]
split_themes = layout.split(percentage=0.2)
sub = split_themes.column()
sub.label(text="Presets:")
subrow = sub.row(align=True)
subrow.menu("USERPREF_MT_interface_theme_p... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'FILES') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
userpref = context.user_preferences
paths = userpref.filepaths
system = userpref.system
split = layout.split(percentage=0.7)
col = split.column()
col.label(text="File Paths:")
colsplit = col.split(percentag... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
input_prefs = context.user_preferences.inputs
is_view3d = context.space_data.type == 'VIEW_3D'
layout.prop(input_prefs, "ndof_sensitivity")
layout.prop(input_prefs, "ndof_orbit_sensitivity")
layout.prop(input_prefs, "ndof_d... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
props = self.layout.operator("wm.context_set_value", text="Blender (default)")
props.data_path = "window_manager.keyconfigs.active"
props.value = "context.window_manager.keyconfigs.default"
# now draw the presets
Menu.draw_preset(self, context) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'INPUT') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw_input_prefs(inputs, layout):
import sys
# General settings
row = layout.row()
col = row.column()
sub = col.column()
sub.label(text="Presets:")
subrow = sub.row(align=True)
subrow.menu("USERPREF_MT_interaction_presets", text=bpy.types.USERPREF_M... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
from rna_keymap_ui import draw_keymaps
layout = self.layout
#import time
#start = time.time()
userpref = context.user_preferences
inputs = userpref.inputs
split = layout.split(percentage=0.25)
# Input settings
self.d... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
layout = self.layout
layout.operator(
"wm.url_open", text="Add-ons Catalog", icon='URL',
).url = "http://wiki.blender.org/index.php/Extensions:2.6/Py/Scripts"
layout.separator()
layout.operator(
"wm.url_open", te... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def poll(cls, context):
userpref = context.user_preferences
return (userpref.active_section == 'ADDONS') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def is_user_addon(mod, user_addon_paths):
import os
if not user_addon_paths:
for path in (bpy.utils.script_path_user(),
bpy.utils.script_path_pref()):
if path is not None:
user_addon_paths.append(os.path.join(path, "addons"))
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw_error(layout, message):
lines = message.split("\n")
box = layout.box()
sub = box.row()
sub.label(lines[0])
sub.label(icon='ERROR')
for l in lines[1:]:
box.label(l) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def draw(self, context):
import os
import addon_utils
layout = self.layout
userpref = context.user_preferences
used_ext = {ext.module for ext in userpref.addons}
userpref_addons_folder = os.path.join(userpref.filepaths.script_directory, "addons")
scripts_addons... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def define_tables(cls, metadata):
Table(
"table1",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("data", String(30)),
)
Table(
"table2",
metadata,
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def memoized(*args):
try:
return stored_results[args]
except KeyError:
result = stored_results[args] = fn(*args)
return result |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_basic(self):
table2, table1 = self.tables.table2, self.tables.table1
Session = scoped_session(sa.orm.sessionmaker(testing.db))
class CustomQuery(query.Query):
pass
class SomeObject(fixtures.ComparableEntity):
query = Session.query_property()
c... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def get_folder_size(folder):
total_size = os.path.getsize(folder)
for item in os.listdir(folder):
itempath = os.path.join(folder, item)
if os.path.isfile(itempath):
total_size += os.path.getsize(itempath)
elif os.path.isdir(itempath):
total_size += get_folder_size... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_config_errors(self):
Session = scoped_session(sa.orm.sessionmaker())
s = Session() # noqa
assert_raises_message(
sa.exc.InvalidRequestError,
"Scoped session is already present",
Session,
bind=testing.db,
)
assert_warns_m... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def usage_iter(root):
root = os.path.abspath(root)
root_size = get_folder_size(root)
root_string = "{0}\n{1}".format(root, root_size)
yield [root_string, None, root_size] |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_call_with_kwargs(self):
mock_scope_func = Mock()
SessionMaker = sa.orm.sessionmaker()
Session = scoped_session(sa.orm.sessionmaker(), mock_scope_func)
s0 = SessionMaker()
assert s0.autoflush == True
mock_scope_func.return_value = 0
s1 = Session()
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def json_usage(root):
root = os.path.abspath(root)
result = [['Path', 'Parent', 'Usage']]
result.extend(entry for entry in usage_iter(root))
return json.dumps(result) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_methods_etc(self):
mock_session = Mock()
mock_session.bind = "the bind"
sess = scoped_session(lambda: mock_session)
sess.add("add")
sess.delete("delete")
sess.get("Cls", 5)
eq_(sess.bind, "the bind")
eq_(
mock_session.mock_calls,
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def main(args):
'''Populates an html template using JSON-formatted output from the
Linux 'du' utility and prints the result'''
html = ''' |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def get_bind(self, mapper=None, **kwargs):
return super().get_bind(mapper=mapper, **kwargs) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def get_bind(self, mapper=None, *args, **kwargs):
return super().get_bind(mapper, *args, **kwargs) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def get_bind(self, mapper=None, *args, **kwargs):
return super(MySession, self).get_bind(
mapper, *args, **kwargs
) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def get_bind(self, mapper=None, **kwargs):
return super(MySession, self).get_bind(
mapper=mapper, **kwargs
) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_reverse_rfc822_datetime():
dates = [
("Sat, 01 Jan 2011 00:00:00 -0000", datetime(2011, 1, 1, tzinfo=pytz.utc)),
("Sat, 01 Jan 2011 23:59:59 -0000", datetime(2011, 1, 1, 23, 59, 59, tzinfo=pytz.utc)),
("Sat, 01 Jan 2011 21:59:59 -0200", datetime(2011, 1, 1, 23, 59, 59, tzinfo=pytz.u... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_reverse_iso8601_datetime():
dates = [
("2011-01-01T00:00:00+00:00", datetime(2011, 1, 1, tzinfo=pytz.utc)),
("2011-01-01T23:59:59+00:00", datetime(2011, 1, 1, 23, 59, 59, tzinfo=pytz.utc)),
("2011-01-01T23:59:59.001000+00:00", datetime(2011, 1, 1, 23, 59, 59, 1000, tzinfo=pytz.utc))... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_urls():
urls = [
'http://www.djangoproject.com/',
'http://localhost/',
'http://example.com/',
'http://www.example.com/',
'http://www.example.com:8000/test',
'http://valid-with-hyphens.com/',
'http://subdomain.example.com/',
'http://200.8.9.10/... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def check_bad_url_raises(value):
try:
inputs.url(value)
assert False, "shouldn't get here"
except ValueError as e:
assert_equal(six.text_type(e), u"{0} is not a valid URL".format(value)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_bad_urls():
values = [
'foo',
'http://',
'http://example',
'http://example.',
'http://.com',
'http://invalid-.com',
'http://-invalid.com',
'http://inv-.alid-.com',
'http://inv-.-alid.com',
'foo bar baz',
u'foo \u2713',
... |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_bad_url_error_message():
values = [
'google.com',
'domain.google.com',
'kevin:pass@google.com/path?query',
u'google.com/path?\u2713',
]
for value in values:
yield check_url_error_message, value |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def check_url_error_message(value):
try:
inputs.url(value)
assert False, u"inputs.url({0}) should raise an exception".format(value)
except ValueError as e:
assert_equal(six.text_type(e),
(u"{0} is not a valid URL. Did you mean: http://{0}".format(value))) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_regex_bad_input():
cases = (
'abc',
'123abc',
'abc123',
'',
)
num_only = inputs.regex(r'^[0-9]+$')
for value in cases:
yield assert_raises, ValueError, lambda: num_only(value) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_regex_good_input():
cases = (
'123',
'1234567890',
'00000',
)
num_only = inputs.regex(r'^[0-9]+$')
for value in cases:
yield assert_equal, num_only(value), value |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_regex_bad_pattern():
"""Regex error raised immediately when regex input parser is created."""
assert_raises(re.error, inputs.regex, '[') |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_regex_flags_good_input():
cases = (
'abcd',
'ABCabc',
'ABC',
)
case_insensitive = inputs.regex(r'^[A-Z]+$', re.IGNORECASE)
for value in cases:
yield assert_equal, case_insensitive(value), value |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_regex_flags_bad_input():
cases = (
'abcd',
'ABCabc'
)
case_sensitive = inputs.regex(r'^[A-Z]+$')
for value in cases:
yield assert_raises, ValueError, lambda: case_sensitive(value) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_boolean_with_python_bool(self):
"""Input that is already a native python `bool` should be passed through
without extra processing."""
assert_equal(inputs.boolean(True), True)
assert_equal(inputs.boolean(False), False) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_bad_boolean(self):
assert_raises(ValueError, lambda: inputs.boolean("blah")) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_date_later_than_1900(self):
assert_equal(inputs.date("1900-01-01"), datetime(1900, 1, 1)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_date_input_error(self):
assert_raises(ValueError, lambda: inputs.date("2008-13-13")) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_date_input(self):
assert_equal(inputs.date("2008-08-01"), datetime(2008, 8, 1)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_natual_negative(self):
assert_raises(ValueError, lambda: inputs.natural(-1)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_natural(self):
assert_equal(3, inputs.natural(3)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_natual_string(self):
assert_raises(ValueError, lambda: inputs.natural('foo')) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_positive(self):
assert_equal(1, inputs.positive(1))
assert_equal(10000, inputs.positive(10000)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_positive_zero(self):
assert_raises(ValueError, lambda: inputs.positive(0)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_positive_negative_input(self):
assert_raises(ValueError, lambda: inputs.positive(-1)) |
def dist(a, b):
return sum((i-j)**2 for i, j in zip(a, b)) | def test_int_range_good(self):
int_range = inputs.int_range(1, 5)
assert_equal(3, int_range(3)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.