class TestA(TestK):
def setUp(self):
self.attr = Attr('mykey')
self.attr2 = Attr('myotherkey')
self.value = 'foo'
self.value2 = 'foo2'
def test_ne(self):
self.assertEqual(self.attr.ne(self.value),
NotEquals(self.attr, self.value))
def test_is_in(self):
self.assertEqual(self.attr.is_in([self.value]),
In(self.attr, [self.value]))
def test_exists(self):
self.assertEqual(self.attr.exists(), AttributeExists(self.attr))
def test_not_exists(self):
self.assertEqual(self.attr.not_exists(), AttributeNotExists(self.attr))
def test_contains(self):
self.assertEqual(self.attr.contains(self.value),
Contains(self.attr, self.value))
def test_size(self):
self.assertEqual(self.attr.size(), Size(self.attr))
def test_attribute_type(self):
self.assertEqual(self.attr.attribute_type(self.value),
AttributeType(self.attr, self.value))
class TestA(TestK):
def setUp(self):
self.attr = Attr("mykey")
self.attr2 = Attr("myotherkey")
self.value = "foo"
self.value2 = "foo2"
def test_ne(self):
self.assertEqual(self.attr.ne(self.value), NotEquals(self.attr, self.value))
def test_is_in(self):
self.assertEqual(self.attr.is_in([self.value]), In(self.attr, [self.value]))
def test_exists(self):
self.assertEqual(self.attr.exists(), AttributeExists(self.attr))
def test_not_exists(self):
self.assertEqual(self.attr.not_exists(), AttributeNotExists(self.attr))
def test_contains(self):
self.assertEqual(self.attr.contains(self.value), Contains(self.attr, self.value))
def test_size(self):
self.assertEqual(self.attr.size(), Size(self.attr))
def test_attribute_type(self):
self.assertEqual(self.attr.attribute_type(self.value), AttributeType(self.attr, self.value))
def test_build_contains(self):
a = Attr('myattr')
self.assert_condition_expression_build(
a.contains('foo'),
'contains(#n0, :v0)',
{'#n0': 'myattr'},
{':v0': 'foo'},
)
def generateAttr(filter_val):
if len(filter_val) > 1:
to_search = ''
for i in range(2, len(filter_val)):
if i == 2:
to_search += filter_val[i]
else:
to_search += ' ' + filter_val[i]
attr_filter = Attr(filter_val[0])
if filter_val[1] == 'eq':
attr_filter = attr_filter.eq(to_search)
elif filter_val[1] == 'contains':
attr_filter = attr_filter.contains(to_search)
elif filter_val[1] == 'lt':
attr_filter = attr_filter.lt(int(filter_val[2]))
elif filter_val[1] == 'gt':
attr_filter = attr_filter.gt(int(filter_val[2]))
return attr_filter
else:
return -1
def get_matches_by_name(self, names):
self.init_table()
attr_name = Attr("name")
names = " ".join(names)
words = [word for word in names.split() if 3 <= len(word)]
filters = [attr_name.contains(word) for word in words]
if not filters:
return []
filter_expression = reduce(lambda left, right: left | right, filters)
response = self.table.scan(FilterExpression=filter_expression)
matches = [clean_dict(item) for item in response["Items"]]
def relevance(match):
name = match["name"]
mean = sum(distance(word, name) for word in words) / len(words)
return mean / len(match)
matches.sort(key=relevance, reverse=True)
return matches
def generate_filter_expression(filter_key: str, filter_cond: str,
filter_value: str) -> dict:
filter_attr = Attr(filter_key)
if filter_cond == "eq":
return {"FilterExpression": filter_attr.eq(filter_value)}
elif filter_cond == "ne":
return {"FilterExpression": filter_attr.eq(filter_value)}
elif filter_cond == "gt":
return {"FilterExpression": filter_attr.gt(filter_value)}
elif filter_cond == "ge":
return {"FilterExpression": filter_attr.gte(filter_value)}
elif filter_cond == "lt":
return {"FilterExpression": filter_attr.lt(filter_value)}
elif filter_cond == "le":
return {"FilterExpression": filter_attr.lte(filter_value)}
elif filter_cond == "begins_with":
return {"FilterExpression": filter_attr.begins_with(filter_value)}
elif filter_cond == "between":
return {"FilterExpression": filter_attr.between(*[filter_value])}
elif filter_cond == "contains":
return {"FilterExpression": filter_attr.contains(filter_value)}
else:
raise AttributeError("filter condition missing")
def _get_targets(self, parsed_targets, db):
overall_cond = None
for i, (key, (invert, type_, value)) in enumerate(parsed_targets.items()):
cond = None
attr = Attr(key)
if type_ == "=":
cond = attr.eq(value)
elif type_ == "<":
cond = attr.lt(value)
elif type_ == ">":
cond = attr.lte(value)
elif type_ == "{":
cond = attr.is_in(value)
elif type_ == "}":
cond = attr.contains(value)
if invert:
cond = ~cond
if overall_cond is None:
overall_cond = cond
else:
overall_cond &= cond
# Return async generator
return db.scan_users(overall_cond, "via_instance, user_id")
class TestA(TestK):
def setUp(self):
self.attr = Attr('mykey')
self.attr2 = Attr('myotherkey')
self.value = 'foo'
self.value2 = 'foo2'
def test_ne(self):
self.assertEqual(self.attr.ne(self.value),
NotEquals(self.attr, self.value))
def test_is_in(self):
self.assertEqual(self.attr.is_in([self.value]),
In(self.attr, [self.value]))
def test_exists(self):
self.assertEqual(self.attr.exists(), AttributeExists(self.attr))
def test_not_exists(self):
self.assertEqual(self.attr.not_exists(), AttributeNotExists(self.attr))
def test_contains(self):
self.assertEqual(self.attr.contains(self.value),
Contains(self.attr, self.value))
def test_size(self):
self.assertEqual(self.attr.size(), Size(self.attr))
def test_attribute_type(self):
self.assertEqual(self.attr.attribute_type(self.value),
AttributeType(self.attr, self.value))
def test_ne_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.ne(self.value)
comp2 = attr_copy.ne(self.value)
self.assertEqual(comp, comp2)
def test_is_in_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.is_in([self.value])
comp2 = attr_copy.is_in([self.value])
self.assertEqual(comp, comp2)
def test_exists_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.exists()
comp2 = attr_copy.exists()
self.assertEqual(comp, comp2)
def test_not_exists_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.not_exists()
comp2 = attr_copy.not_exists()
self.assertEqual(comp, comp2)
def test_contains_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.contains(self.value)
comp2 = attr_copy.contains(self.value)
self.assertEqual(comp, comp2)
def test_size_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.size()
comp2 = attr_copy.size()
self.assertEqual(comp, comp2)
def test_attribute_type_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.attribute_type(self.value)
comp2 = attr_copy.attribute_type(self.value)
self.assertEqual(comp, comp2)
def test_build_contains(self):
a = Attr('myattr')
self.assert_condition_expression_build(
a.contains('foo'), 'contains(#n0, :v0)',
{'#n0': 'myattr'}, {':v0': 'foo'})
class TestA(TestK):
def setUp(self):
self.attr = Attr('mykey')
self.attr2 = Attr('myotherkey')
self.value = 'foo'
self.value2 = 'foo2'
def test_ne(self):
self.assertEqual(self.attr.ne(self.value),
NotEquals(self.attr, self.value))
def test_is_in(self):
self.assertEqual(self.attr.is_in([self.value]),
In(self.attr, [self.value]))
def test_exists(self):
self.assertEqual(self.attr.exists(), AttributeExists(self.attr))
def test_not_exists(self):
self.assertEqual(self.attr.not_exists(), AttributeNotExists(self.attr))
def test_contains(self):
self.assertEqual(self.attr.contains(self.value),
Contains(self.attr, self.value))
def test_size(self):
self.assertEqual(self.attr.size(), Size(self.attr))
def test_attribute_type(self):
self.assertEqual(self.attr.attribute_type(self.value),
AttributeType(self.attr, self.value))
def test_ne_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.ne(self.value)
comp2 = attr_copy.ne(self.value)
self.assertEqual(comp, comp2)
def test_is_in_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.is_in([self.value])
comp2 = attr_copy.is_in([self.value])
self.assertEqual(comp, comp2)
def test_exists_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.exists()
comp2 = attr_copy.exists()
self.assertEqual(comp, comp2)
def test_not_exists_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.not_exists()
comp2 = attr_copy.not_exists()
self.assertEqual(comp, comp2)
def test_contains_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.contains(self.value)
comp2 = attr_copy.contains(self.value)
self.assertEqual(comp, comp2)
def test_size_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.size()
comp2 = attr_copy.size()
self.assertEqual(comp, comp2)
def test_attribute_type_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.attribute_type(self.value)
comp2 = attr_copy.attribute_type(self.value)
self.assertEqual(comp, comp2)
def test_build_contains(self):
a = Attr("myattr")
self.assert_condition_expression_build(
a.contains("foo"), "contains(#n0, :v0)", {"#n0": "myattr"}, {":v0": "foo"}
)
class TestA(TestK):
def setUp(self):
self.attr = Attr('mykey')
self.attr2 = Attr('myotherkey')
self.value = 'foo'
self.value2 = 'foo2'
def test_ne(self):
assert self.attr.ne(self.value) == NotEquals(self.attr, self.value)
def test_is_in(self):
assert self.attr.is_in([self.value]) == In(self.attr, [self.value])
def test_exists(self):
assert self.attr.exists() == AttributeExists(self.attr)
def test_not_exists(self):
assert self.attr.not_exists() == AttributeNotExists(self.attr)
def test_contains(self):
assert self.attr.contains(self.value) == Contains(
self.attr, self.value)
def test_size(self):
assert self.attr.size() == Size(self.attr)
def test_attribute_type(self):
assert self.attr.attribute_type(self.value) == AttributeType(
self.attr, self.value)
def test_ne_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.ne(self.value)
comp2 = attr_copy.ne(self.value)
assert comp == comp2
def test_is_in_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.is_in([self.value])
comp2 = attr_copy.is_in([self.value])
assert comp == comp2
def test_exists_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.exists()
comp2 = attr_copy.exists()
assert comp == comp2
def test_not_exists_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.not_exists()
comp2 = attr_copy.not_exists()
assert comp == comp2
def test_contains_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.contains(self.value)
comp2 = attr_copy.contains(self.value)
assert comp == comp2
def test_size_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.size()
comp2 = attr_copy.size()
assert comp == comp2
def test_attribute_type_equality(self):
attr_copy = copy.deepcopy(self.attr)
comp = self.attr.attribute_type(self.value)
comp2 = attr_copy.attribute_type(self.value)
assert comp == comp2
