query stringlengths 9 9.05k | document stringlengths 10 222k | metadata dict | negatives listlengths 30 30 | negative_scores listlengths 30 30 | document_score stringlengths 4 10 | document_rank stringclasses 2
values |
|---|---|---|---|---|---|---|
Update a bin with resize using the update only flag. | def test_bit_resize_update_only_allows_update(self):
bit_policy = {"bit_write_flags": aerospike.BIT_WRITE_UPDATE_ONLY}
ops = [bitwise_operations.bit_resize(self.test_bin_zeroes, 10, policy=bit_policy)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_resize_update_only_prevents_create(self):\n bit_policy = {\"bit_write_flags\": aerospike.BIT_WRITE_UPDATE_ONLY}\n ops = [bitwise_operations.bit_resize(\"new_binname\", 10, policy=bit_policy)]\n with pytest.raises(e.BinNotFound):\n self.as_connection.operate(self.test_ke... | [
"0.69057226",
"0.65416884",
"0.641748",
"0.6385027",
"0.63735026",
"0.6240761",
"0.6216285",
"0.61025584",
"0.604929",
"0.60121477",
"0.5909513",
"0.58421",
"0.58233666",
"0.57920974",
"0.5786729",
"0.57516265",
"0.5671128",
"0.56705207",
"0.5624751",
"0.56244254",
"0.5577843... | 0.7411978 | 0 |
Attempt to update a bin using the create only flag, should fail. | def test_bit_resize_create_only_prevents_update(self):
bit_policy = {"bit_write_flags": aerospike.BIT_WRITE_CREATE_ONLY}
ops = [bitwise_operations.bit_resize(self.test_bin_zeroes, 10, policy=bit_policy)]
with pytest.raises(e.BinExistsError):
self.as_connection.operate(self.test_key, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_resize_update_only_prevents_create(self):\n bit_policy = {\"bit_write_flags\": aerospike.BIT_WRITE_UPDATE_ONLY}\n ops = [bitwise_operations.bit_resize(\"new_binname\", 10, policy=bit_policy)]\n with pytest.raises(e.BinNotFound):\n self.as_connection.operate(self.test_ke... | [
"0.72131586",
"0.6276118",
"0.62251824",
"0.5943193",
"0.58890015",
"0.58799314",
"0.5723462",
"0.57154715",
"0.5468486",
"0.53320503",
"0.53023577",
"0.52670854",
"0.5260081",
"0.5243067",
"0.5186186",
"0.5182294",
"0.51734173",
"0.5149509",
"0.51302",
"0.51124716",
"0.50859... | 0.67461276 | 1 |
Attempt to create a bin with the update only flag. | def test_bit_resize_update_only_prevents_create(self):
bit_policy = {"bit_write_flags": aerospike.BIT_WRITE_UPDATE_ONLY}
ops = [bitwise_operations.bit_resize("new_binname", 10, policy=bit_policy)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_resize_create_only_prevents_update(self):\n bit_policy = {\"bit_write_flags\": aerospike.BIT_WRITE_CREATE_ONLY}\n ops = [bitwise_operations.bit_resize(self.test_bin_zeroes, 10, policy=bit_policy)]\n with pytest.raises(e.BinExistsError):\n self.as_connection.operate(self... | [
"0.66729695",
"0.642562",
"0.5968319",
"0.5948694",
"0.5577203",
"0.5466079",
"0.5336632",
"0.5324112",
"0.5314014",
"0.5188824",
"0.50772935",
"0.50578123",
"0.5012339",
"0.49814543",
"0.49732277",
"0.49634764",
"0.49508432",
"0.49255985",
"0.49150288",
"0.49061385",
"0.4899... | 0.68357843 | 0 |
Perform a bit_remove op with random offset and random byte_size. | def test_bit_remove_randnumbytes_randoffset(self):
offset = random.randint(0, 4)
num_bytes = random.randint(1, (5 - offset))
ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, offset, num_bytes, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_remove_byte_offset_with_byte_too_large(self):\n ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 3, 3, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_remove_byte_size_too_large(self):\n ops =... | [
"0.7460626",
"0.7029435",
"0.6697363",
"0.612828",
"0.58275354",
"0.5671818",
"0.5525168",
"0.54080635",
"0.54062444",
"0.53846896",
"0.53723586",
"0.5365333",
"0.53497666",
"0.53403485",
"0.53399885",
"0.5328281",
"0.5322385",
"0.53183216",
"0.52913463",
"0.52527755",
"0.524... | 0.8260266 | 0 |
Perform a bit_remove op with an offset outside the bit_map being modified. | def test_bit_remove_offset_out_of_range(self):
ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 6, 1, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_remove_byte_offset_with_byte_too_large(self):\n ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 3, 3, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_remove_randnumbytes_randoffset(self):\n o... | [
"0.6892283",
"0.6586158",
"0.6565213",
"0.6270239",
"0.59938574",
"0.5886865",
"0.57899576",
"0.57643443",
"0.5681459",
"0.5676396",
"0.5671734",
"0.5641111",
"0.5604822",
"0.5602166",
"0.5552755",
"0.55470186",
"0.5542133",
"0.55227333",
"0.5515977",
"0.5514617",
"0.550996",... | 0.7176135 | 0 |
Perform a bit_remove op with byte_size larger than bit_map being modified. | def test_bit_remove_byte_size_too_large(self):
ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 0, 6, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_remove_byte_offset_with_byte_too_large(self):\n ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 3, 3, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_remove_randnumbytes_randoffset(self):\n o... | [
"0.722026",
"0.63428634",
"0.6251677",
"0.6056598",
"0.58716387",
"0.58648276",
"0.55580854",
"0.553342",
"0.55312115",
"0.55277854",
"0.5504092",
"0.54698414",
"0.5469348",
"0.54454875",
"0.53916377",
"0.5335044",
"0.5326309",
"0.52946264",
"0.52848536",
"0.5278192",
"0.5261... | 0.72622025 | 0 |
Perform a bit_remove op with an offset and byte_size that attempt to modify the bitmap outside of bounds. | def test_bit_remove_byte_offset_with_byte_too_large(self):
ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 3, 3, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_remove_offset_out_of_range(self):\n ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 6, 1, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_remove_byte_size_too_large(self):\n ops = [bitwise_op... | [
"0.70188206",
"0.6904221",
"0.65545523",
"0.61256516",
"0.58739406",
"0.5819776",
"0.57718444",
"0.5766656",
"0.5707339",
"0.5700624",
"0.5694595",
"0.568376",
"0.5648815",
"0.5548685",
"0.5532302",
"0.55302817",
"0.5436966",
"0.54173505",
"0.53808784",
"0.53792065",
"0.53229... | 0.7540604 | 0 |
Perform a bit_remove op with on a non existent bin. | def test_bit_remove_bad_bin_name(self):
ops = [bitwise_operations.bit_remove("bad_name", 3, 3, None)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_remove_two_bytes(self):\n ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 1, 2, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n assert bins[self.test_bin_zeroes] == bytearray([0] * 3)\n # sho... | [
"0.68756264",
"0.66447246",
"0.6498532",
"0.648801",
"0.6431087",
"0.6427044",
"0.6342931",
"0.6317461",
"0.6307187",
"0.6265406",
"0.625727",
"0.6016103",
"0.5976674",
"0.59601295",
"0.5937234",
"0.5903448",
"0.58924925",
"0.58427477",
"0.58268416",
"0.5820784",
"0.57978046"... | 0.71839386 | 0 |
Perform a bit_remove op with an unsupported float type argument. | def test_bit_remove_bad_arg_type(self):
ops = [bitwise_operations.bit_remove("bad_name", 3, 3.5, None)]
with pytest.raises(e.ParamError):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_isub_with_float_argument(self):\n\n a = Vec3(2, 3, 4)\n b = 1.0\n\n a -= b\n\n expected_result = Vec3(1, 2, 3)\n\n self.assertEqual(a, expected_result)",
"def upgrade_to_float_no_complex(*types):\r\n for type in types:\r\n if type in complex_types:\r\n ... | [
"0.5411757",
"0.540019",
"0.53913176",
"0.5297443",
"0.52850366",
"0.52799785",
"0.52562046",
"0.5226235",
"0.518611",
"0.5149058",
"0.51441497",
"0.5123272",
"0.5087803",
"0.5081965",
"0.5056962",
"0.50403166",
"0.5002864",
"0.4964705",
"0.49551713",
"0.49255654",
"0.4921956... | 0.63819206 | 0 |
Perform a bit_set op with a random offset and random valued byte. | def test_bit_set_bit_random_byte_random_offset(self):
value = bytearray()
rand_byte = random.randint(0, 255)
value.append(rand_byte)
rand_offset = random.randint(0, 4) * 8
ops = [bitwise_operations.bit_set(self.test_bin_zeroes, rand_offset, 8, 1, value, None)]
self.as_con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_set_bit_multiple_bytes(self):\n value = bytearray()\n value = bytearray()\n rand_byte = random.randint(0, 255)\n num_bytes = random.randint(1, 5)\n for x in range(0, num_bytes):\n value.append(rand_byte)\n ops = [bitwise_operations.bit_set(self.test... | [
"0.70580727",
"0.66288537",
"0.6617896",
"0.634463",
"0.6326759",
"0.627388",
"0.61899483",
"0.59698194",
"0.5968973",
"0.5948081",
"0.58074385",
"0.57888424",
"0.57555",
"0.57530206",
"0.5752519",
"0.5679028",
"0.5649676",
"0.56445855",
"0.5620908",
"0.5613202",
"0.5593376",... | 0.8364399 | 0 |
Perform a bit_set op with a random number of bytes. | def test_bit_set_bit_multiple_bytes(self):
value = bytearray()
value = bytearray()
rand_byte = random.randint(0, 255)
num_bytes = random.randint(1, 5)
for x in range(0, num_bytes):
value.append(rand_byte)
ops = [bitwise_operations.bit_set(self.test_bin_zeroes,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_set_bit_random_byte_random_offset(self):\n value = bytearray()\n rand_byte = random.randint(0, 255)\n value.append(rand_byte)\n rand_offset = random.randint(0, 4) * 8\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, rand_offset, 8, 1, value, None)]\n ... | [
"0.77750814",
"0.6959667",
"0.674012",
"0.66950464",
"0.6299832",
"0.6254417",
"0.61801815",
"0.611885",
"0.6047925",
"0.6023438",
"0.6009793",
"0.5964243",
"0.59179986",
"0.5877488",
"0.5867968",
"0.58303803",
"0.5787363",
"0.57502264",
"0.56951576",
"0.5691238",
"0.5686461"... | 0.76584923 | 1 |
Perform a bit_set op with an bit size larger than the actual value. | def test_bit_set_bit_bit_size_too_large(self):
value = bytearray()
value.append(255)
ops = [bitwise_operations.bit_set(self.test_bin_zeroes, 0, 16, 1, value, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_set_bit_value_size_too_large(self):\n value = bytearray()\n for x in range(0, 5):\n value.append(255)\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, 0, 48, 6, value, None)]\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operat... | [
"0.77699894",
"0.6594298",
"0.6497174",
"0.6339704",
"0.6304334",
"0.6257113",
"0.6206651",
"0.620033",
"0.61832565",
"0.6174593",
"0.610813",
"0.61076254",
"0.6104633",
"0.60604364",
"0.6015046",
"0.5987889",
"0.5957026",
"0.59446806",
"0.59208137",
"0.5900072",
"0.58730924"... | 0.78068256 | 0 |
Perform a bit_set op with an unsupported float. | def test_bit_set_bit_invalid_arg_type(self):
value = 85323.9
ops = [bitwise_operations.bit_set(self.test_bin_zeroes, 0, 8, 1, value, None)]
with pytest.raises(e.ParamError):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _setFloatFeature(self, valueToSet):\n\n errorCode = VimbaDLL.featureFloatSet(self._handle,\n self._name,\n valueToSet)\n if errorCode != 0:\n raise VimbaException(errorCode)",
"def setFloat(self, ... | [
"0.6770153",
"0.6004491",
"0.58763963",
"0.57682735",
"0.5760419",
"0.55618626",
"0.55370873",
"0.54370934",
"0.54367065",
"0.5423097",
"0.54175943",
"0.538118",
"0.53563106",
"0.5343038",
"0.53324986",
"0.5331044",
"0.53261274",
"0.5292256",
"0.5281855",
"0.52734023",
"0.526... | 0.69059694 | 0 |
Perform a bit_set op with a non existent bin. | def test_bit_set_bit_bad_bin_name(self):
value = bytearray()
value.append(255)
ops = [bitwise_operations.bit_set("bad_name", 0, 8, 1, value, None)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_set_bit_index_out_of_range(self):\n value = bytearray()\n value.append(255)\n ops = [bitwise_operations.bit_set(self.test_bin_zeroes, 41, 8, 1, value, None)]\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_b... | [
"0.7023662",
"0.7013182",
"0.6553143",
"0.6487933",
"0.64827436",
"0.64403266",
"0.6393664",
"0.6350938",
"0.6335981",
"0.6330965",
"0.62376326",
"0.6232921",
"0.6223009",
"0.621056",
"0.61761284",
"0.61017376",
"0.60678023",
"0.59541297",
"0.5921793",
"0.59187233",
"0.58331"... | 0.70514387 | 0 |
Perform a bitwise count op. | def test_bit_count_seven(self):
ops = [bitwise_operations.bit_count(self.count_bin, 20, 9)]
_, _, result = self.as_connection.operate(self.test_key, ops)
assert result["count"] == 7 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_count_one(self):\n ops = [bitwise_operations.bit_count(self.zero_one_bin, 47, 8)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[\"bitwise01\"] == 1",
"def shitty_count_set_bits(num:int) -> int:\n count = 0\n while num != 0:\n coun... | [
"0.71469164",
"0.7065721",
"0.7011086",
"0.69618213",
"0.69151825",
"0.67142653",
"0.6712387",
"0.6662766",
"0.6643679",
"0.6571938",
"0.6570812",
"0.64751136",
"0.6398726",
"0.6366944",
"0.6325615",
"0.62976414",
"0.62906784",
"0.62676513",
"0.62547326",
"0.62028843",
"0.613... | 0.7423666 | 0 |
Perform a bitwise count op. | def test_bit_count_one(self):
ops = [bitwise_operations.bit_count(self.zero_one_bin, 47, 8)]
_, _, result = self.as_connection.operate(self.test_key, ops)
assert result["bitwise01"] == 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_count_seven(self):\n ops = [bitwise_operations.bit_count(self.count_bin, 20, 9)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[\"count\"] == 7",
"def shitty_count_set_bits(num:int) -> int:\n count = 0\n while num != 0:\n count += ... | [
"0.7423666",
"0.7065721",
"0.7011086",
"0.69618213",
"0.69151825",
"0.67142653",
"0.6712387",
"0.6662766",
"0.6643679",
"0.6571938",
"0.6570812",
"0.64751136",
"0.6398726",
"0.6366944",
"0.6325615",
"0.62976414",
"0.62906784",
"0.62676513",
"0.62547326",
"0.62028843",
"0.6131... | 0.71469164 | 1 |
Attempts to perform a bitwise count op with bit_offset outside of the bitmap being counted. | def test_bit_count_bit_offset_out_of_range(self):
ops = [bitwise_operations.bit_count(self.zero_one_bin, 81, 1)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_count_bit_size_with_offset_too_large(self):\n ops = [bitwise_operations.bit_count(self.zero_one_bin, 40, 41)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def count_set_bits(bitmap):\n bmp = bitmap\n count = 0\n n = ... | [
"0.7564361",
"0.6940996",
"0.66964185",
"0.6547453",
"0.6341447",
"0.6273543",
"0.6123219",
"0.60676616",
"0.60630244",
"0.6039324",
"0.59491664",
"0.5912704",
"0.5888373",
"0.5875139",
"0.5827622",
"0.57833576",
"0.5767076",
"0.5763469",
"0.57452416",
"0.5737628",
"0.5720858... | 0.7624135 | 0 |
Attempts to perform a bitwise count op on more bits than exist. | def test_bit_count_bit_size_too_large(self):
ops = [bitwise_operations.bit_count(self.zero_one_bin, 1, 81)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_count_bit_size_with_offset_too_large(self):\n ops = [bitwise_operations.bit_count(self.zero_one_bin, 40, 41)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def shitty_count_set_bits(num:int) -> int:\n count = 0\n while n... | [
"0.7497445",
"0.7358652",
"0.7324532",
"0.7311619",
"0.7215626",
"0.71455824",
"0.7142483",
"0.6930695",
"0.69203246",
"0.6908501",
"0.6842946",
"0.68328786",
"0.67919254",
"0.67240614",
"0.66319263",
"0.66273886",
"0.6610012",
"0.6564041",
"0.6498201",
"0.64961916",
"0.64404... | 0.7900154 | 0 |
Perform a bitwise add op. | def test_bit_add_simple(self):
ops = [bitwise_operations.bit_add(self.test_bin_ones, 0, 8, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([2] * 1 + [1] * 4)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ff_add(a, b):\n return a ^ b",
"def add(num1,num2):\n if(num2==0):\n return num1\n return add((num1^num2),(num1&num2)<<1)",
"def add(self, a, b):\n return a + b",
"def plus(self, other):\n return self | other",
"def __add__(self, other):\n\n return self._binary_elementwise_... | [
"0.72715294",
"0.7098102",
"0.70803595",
"0.70718306",
"0.69956553",
"0.6975312",
"0.69086856",
"0.68694097",
"0.68667156",
"0.6845859",
"0.67594755",
"0.67444706",
"0.67444706",
"0.67444706",
"0.67444706",
"0.67444706",
"0.67444706",
"0.6738565",
"0.66684777",
"0.6663798",
"... | 0.71233565 | 1 |
Perform a bitwise add op with an offset that lands inbetween bytes. | def test_bit_add_inbetween_bytes(self):
ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 4, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([15] * 1 +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _uint8_add(self, a, b):\n return ((a & 0xFF) + (b & 0xFF)) & 0xFF",
"def add_binary(a, b):\n return bin(a + b)[2:]",
"def _add(a, b):\n\n # Todo: What if numbers have bigger length than 8\n a = _I2B(a, fixed_length=8)\n b = _I2B(b, fixed_length=8)\n return _B2I([i ^ j for i, j in zip(... | [
"0.6895345",
"0.64765716",
"0.6331206",
"0.6284761",
"0.61512357",
"0.61413187",
"0.6051106",
"0.59600806",
"0.59311205",
"0.5892663",
"0.588553",
"0.5865346",
"0.5851213",
"0.58214045",
"0.581817",
"0.5771626",
"0.570471",
"0.57009697",
"0.56927943",
"0.5666603",
"0.5655928"... | 0.67608523 | 1 |
Perform a bitwise add op with multiple bytes. | def test_bit_add_multiple_bytes(self):
ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 8, 16, 65535, False, aerospike.BIT_OVERFLOW_FAIL, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([0] * 1 ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add(a, b):\n\n # Todo: What if numbers have bigger length than 8\n a = _I2B(a, fixed_length=8)\n b = _I2B(b, fixed_length=8)\n return _B2I([i ^ j for i, j in zip(a, b)])",
"def _uint8_add(self, a, b):\n return ((a & 0xFF) + (b & 0xFF)) & 0xFF",
"def test_bit_add_inbetween_bytes(self):\n... | [
"0.72455776",
"0.698561",
"0.6880169",
"0.67817104",
"0.6642168",
"0.6629964",
"0.65817994",
"0.64933366",
"0.648726",
"0.6482742",
"0.64505666",
"0.64498633",
"0.6417345",
"0.63390696",
"0.62232685",
"0.62040883",
"0.61814713",
"0.61686695",
"0.61275816",
"0.6070808",
"0.606... | 0.749226 | 0 |
Perform a bitwise add op on a nonexistent bin. | def test_bit_add_bad_bin_name(self):
ops = [bitwise_operations.bit_add("bad_name", 8, 16, 65535, False, aerospike.BIT_OVERFLOW_FAIL, None)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_insert_nonexistent_bin_name(self):\n value = bytearray([3])\n ops = [bitwise_operations.bit_insert(\"bad_name\", 0, 1, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearra... | [
"0.6802543",
"0.6767682",
"0.67084956",
"0.6646982",
"0.6610624",
"0.6578335",
"0.65743756",
"0.6384216",
"0.63737106",
"0.6267375",
"0.62592363",
"0.61435515",
"0.5965178",
"0.594939",
"0.5888015",
"0.583687",
"0.583003",
"0.5779049",
"0.57335335",
"0.57301044",
"0.56188434"... | 0.76569134 | 0 |
Perform a bitwise add op with a bit_offset that is out of range for the bitmap being modified. | def test_bit_add_bit_offset_out_of_range(self):
ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 41, 1, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_add_bit_size_out_of_range(self):\n ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 0, 41, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_add_overflow_fail(self)... | [
"0.65838915",
"0.64080894",
"0.6319045",
"0.62099093",
"0.61947215",
"0.6159893",
"0.6152461",
"0.6120678",
"0.6107185",
"0.5956836",
"0.58519316",
"0.58213335",
"0.5794799",
"0.5746909",
"0.5732208",
"0.56775117",
"0.56739074",
"0.5650088",
"0.5588641",
"0.5560465",
"0.55446... | 0.73627174 | 0 |
Perform a bitwise add op with a bit size too large for the bitmap being modified. | def test_bit_add_bit_size_out_of_range(self):
ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 0, 41, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_add_bit_size_signed(self):\n ops = [bitwise_operations.bit_add(self.five_255_bin, 0, 8, 254, True, aerospike.BIT_OVERFLOW_WRAP, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([25... | [
"0.6542242",
"0.64941835",
"0.62195337",
"0.61419046",
"0.61222196",
"0.6112536",
"0.6070879",
"0.6046138",
"0.59929603",
"0.5990503",
"0.597197",
"0.59605044",
"0.590751",
"0.5876018",
"0.5792255",
"0.57701886",
"0.5666809",
"0.56660813",
"0.56307065",
"0.5619407",
"0.561452... | 0.66088796 | 0 |
Perform a bitwise add op that overflows with the BIT_OVERFLOW_FAIL action. | def test_bit_add_overflow_fail(self):
ops = [bitwise_operations.bit_add(self.five_255_bin, 0, 8, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_add_bit_offset_out_of_range(self):\n ops = [bitwise_operations.bit_add(self.test_bin_zeroes, 41, 1, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_add_bit_size_out_of_r... | [
"0.7437843",
"0.7397968",
"0.6988565",
"0.6652772",
"0.65746254",
"0.65476197",
"0.63244146",
"0.63017803",
"0.62115306",
"0.6129045",
"0.6089315",
"0.60318506",
"0.6009601",
"0.5929405",
"0.5805147",
"0.578539",
"0.5765352",
"0.5743154",
"0.5705865",
"0.5704055",
"0.5703668"... | 0.8252985 | 0 |
Perform a bitwise add op that overflows with the BIT_OVERFLOW_SATURATE action. | def test_bit_add_overflow_saturate(self):
ops = [bitwise_operations.bit_add(self.five_255_bin, 0, 8, 1, False, aerospike.BIT_OVERFLOW_SATURATE, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([255] * 5... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_add_overflow_fail(self):\n ops = [bitwise_operations.bit_add(self.five_255_bin, 0, 8, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_add_overflow_wrap(self):\n o... | [
"0.7303214",
"0.70369244",
"0.6906154",
"0.6778493",
"0.6674004",
"0.64422286",
"0.633672",
"0.6162586",
"0.6078986",
"0.5818981",
"0.5817478",
"0.57848686",
"0.5755819",
"0.57219166",
"0.57161057",
"0.5714408",
"0.5697552",
"0.5672356",
"0.5642903",
"0.5629903",
"0.56281734"... | 0.72117203 | 1 |
Perform a bitwise add op that overflows with the BIT_OVERFLOW_WRAP action. | def test_bit_add_overflow_wrap(self):
ops = [bitwise_operations.bit_add(self.five_255_bin, 0, 8, 1, False, aerospike.BIT_OVERFLOW_WRAP, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([0] * 1 + [255] *... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_add_overflow_fail(self):\n ops = [bitwise_operations.bit_add(self.five_255_bin, 0, 8, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_add_bit_size_out_of_range(self):\n ... | [
"0.69865286",
"0.63499284",
"0.6259732",
"0.6231338",
"0.6189133",
"0.6175745",
"0.61683786",
"0.609293",
"0.6042137",
"0.6023715",
"0.5987507",
"0.5873115",
"0.58514667",
"0.58116734",
"0.57713294",
"0.574729",
"0.5737004",
"0.5733803",
"0.56554",
"0.5628457",
"0.5598145",
... | 0.74974084 | 0 |
Perform a bitwise and op with value large enough to span multiple bytes. | def test_bit_and_multiple_bytes(self):
value = bytearray()
value.append(1)
value.append(1)
value.append(1)
ops = [bitwise_operations.bit_and(self.five_255_bin, 8, 17, 3, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_and_across_bytes(self):\n value = bytearray()\n value.append(0)\n ops = [bitwise_operations.bit_and(self.five_255_bin, 7, 8, 1, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_r... | [
"0.7053533",
"0.68397754",
"0.6709027",
"0.66512394",
"0.6600164",
"0.6542796",
"0.6499277",
"0.62920785",
"0.6157668",
"0.6039458",
"0.60247964",
"0.59498256",
"0.59160185",
"0.5909005",
"0.58582497",
"0.5846487",
"0.5832019",
"0.5819976",
"0.5740326",
"0.57323074",
"0.56576... | 0.7077078 | 0 |
Perform a bitwise and op with a bit_size > the size of value. | def test_bit_and_offset_bit_size_larger_than_val(self):
value = bytearray()
value.append(0)
ops = [bitwise_operations.bit_and(self.five_255_bin, 0, 16, 1, value, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_and_offset_value_byte_size_too_large(self):\n value = bytearray()\n for x in range(0, 5):\n value.append(0)\n ops = [bitwise_operations.bit_and(self.five_255_bin, 0, 48, 6, value, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.o... | [
"0.66505015",
"0.6267172",
"0.6213419",
"0.61219025",
"0.6011456",
"0.5915263",
"0.58221704",
"0.5815698",
"0.579385",
"0.5749901",
"0.57298887",
"0.5679415",
"0.5606196",
"0.5568124",
"0.5551867",
"0.5548409",
"0.5525523",
"0.5524242",
"0.5467059",
"0.5379395",
"0.53744006",... | 0.7103795 | 0 |
Perform a bitwise and op with a value_byte_size larger than the bitmap being modified. | def test_bit_and_offset_value_byte_size_too_large(self):
value = bytearray()
for x in range(0, 5):
value.append(0)
ops = [bitwise_operations.bit_and(self.five_255_bin, 0, 48, 6, value, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_and_offset_bit_size_larger_than_val(self):\n value = bytearray()\n value.append(0)\n ops = [bitwise_operations.bit_and(self.five_255_bin, 0, 16, 1, value, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def t... | [
"0.68500006",
"0.6666652",
"0.64749104",
"0.6296524",
"0.6243885",
"0.58637655",
"0.58447677",
"0.5794284",
"0.5770545",
"0.5637839",
"0.56156445",
"0.5608388",
"0.5604958",
"0.5556106",
"0.5555062",
"0.55270344",
"0.5524201",
"0.551075",
"0.55024546",
"0.5488388",
"0.5476835... | 0.6712595 | 1 |
Perform a bitwise and op with a non existent bin name. | def test_bit_and_invalid_bin_name(self):
value = bytearray()
value.append(0)
ops = [bitwise_operations.bit_and("bad_name", 0, 8, 1, value, None)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_and(self):\n value = bytearray()\n value.append(0)\n ops = [bitwise_operations.bit_and(self.five_255_bin, 0, 8, 1, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytea... | [
"0.6510834",
"0.6441707",
"0.6261121",
"0.62495655",
"0.62354034",
"0.6178037",
"0.6170451",
"0.6150072",
"0.61430025",
"0.61324114",
"0.60920554",
"0.6063773",
"0.6020918",
"0.5954678",
"0.58549696",
"0.5835591",
"0.58223265",
"0.57884556",
"0.57821554",
"0.570214",
"0.56394... | 0.762801 | 0 |
Perform a bitwise get op. | def test_bit_get(self):
ops = [bitwise_operations.bit_get(self.five_255_bin, 0, 8)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = bytearray([255] * 1)
assert result["255"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_accross_bytes(self):\n ops = [bitwise_operations.bit_get(self.test_bin_ones, 4, 8)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = bytearray([16] * 1)\n assert result[\"bitwise1\"] == expected_result",
"def bit_get(val, idx):\n... | [
"0.7000506",
"0.6605296",
"0.6504855",
"0.6378649",
"0.62414247",
"0.61625886",
"0.6146228",
"0.61241513",
"0.610408",
"0.6011124",
"0.5796253",
"0.57583314",
"0.57545096",
"0.56891155",
"0.5669531",
"0.56524837",
"0.5637581",
"0.56328243",
"0.5563451",
"0.55194074",
"0.55118... | 0.6793469 | 1 |
Perform a bitwise get op with a negative offset. | def test_bit_get_negative_offset(self):
ops = [bitwise_operations.bit_get(self.count_bin, -2, 2)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = bytearray([192] * 1)
assert result[self.count_bin] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_bit_offset_out_of_range(self):\n ops = [bitwise_operations.bit_get(self.test_bin_ones, 41, 1)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_subtract_bit_offset_out_of_range(self):\n ops = [\n ... | [
"0.6487363",
"0.63536626",
"0.6093398",
"0.60396236",
"0.5953041",
"0.58536357",
"0.5741644",
"0.56206924",
"0.55487245",
"0.54852706",
"0.54610914",
"0.5309807",
"0.5308505",
"0.5308271",
"0.52730584",
"0.5258959",
"0.5250486",
"0.5231087",
"0.5225644",
"0.5214675",
"0.52085... | 0.7575732 | 0 |
Perform a bitwise get op across bytes. | def test_bit_get_accross_bytes(self):
ops = [bitwise_operations.bit_get(self.test_bin_ones, 4, 8)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = bytearray([16] * 1)
assert result["bitwise1"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int_accross_bytes(self):\n ops = [bitwise_operations.bit_get_int(self.test_bin_ones, 4, 8, False)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = 16\n assert result[\"bitwise1\"] == expected_result",
"def test_bit_get_multiple_... | [
"0.7051059",
"0.6728604",
"0.66430426",
"0.6132444",
"0.6119449",
"0.60101527",
"0.5942671",
"0.5909405",
"0.5893895",
"0.5889837",
"0.5881569",
"0.5854613",
"0.5784683",
"0.57692033",
"0.57260805",
"0.5660203",
"0.565209",
"0.56341773",
"0.5623387",
"0.56132615",
"0.5611499"... | 0.75417405 | 0 |
Perform a bitwise get op across multiple bytes. | def test_bit_get_multiple_bytes(self):
ops = [bitwise_operations.bit_get(self.five_255_bin, 4, 17)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = bytearray([255] * 2 + [128] * 1)
assert result["255"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_accross_bytes(self):\n ops = [bitwise_operations.bit_get(self.test_bin_ones, 4, 8)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = bytearray([16] * 1)\n assert result[\"bitwise1\"] == expected_result",
"def test_bit_get_int_acc... | [
"0.7147852",
"0.66116863",
"0.652621",
"0.6177915",
"0.5853398",
"0.57564133",
"0.5710771",
"0.56699646",
"0.5662459",
"0.56446254",
"0.55893993",
"0.55710304",
"0.55414647",
"0.55307996",
"0.55051976",
"0.5418046",
"0.5379218",
"0.5309492",
"0.5307577",
"0.5278677",
"0.52720... | 0.715834 | 0 |
Perform a bitwise get with a bit_size larger than the bitmap being read. | def test_bit_get_bit_size_too_large(self):
ops = [bitwise_operations.bit_get(self.test_bin_ones, 0, 41)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int_bit_size_too_large(self):\n ops = [bitwise_operations.bit_get_int(self.test_bin_ones, 0, 41, False)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_get(self):\n ops = [bitwise_operations.bit_get(self... | [
"0.62875754",
"0.6210807",
"0.6210594",
"0.6104591",
"0.60731876",
"0.60564893",
"0.5981193",
"0.5877708",
"0.5841703",
"0.5830928",
"0.5824218",
"0.58029646",
"0.5789045",
"0.5782011",
"0.5763841",
"0.5663442",
"0.5663405",
"0.566137",
"0.5659523",
"0.56565785",
"0.56256235"... | 0.6607144 | 0 |
Perform a bitwise get with a non existent bin. | def test_bit_get_bad_bin_name(self):
ops = [bitwise_operations.bit_get("bad_name", 0, 1)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = None
assert result["bad_name"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_negative_offset(self):\n ops = [bitwise_operations.bit_get(self.count_bin, -2, 2)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = bytearray([192] * 1)\n assert result[self.count_bin] == expected_result",
"def test_bit_get_int_b... | [
"0.65858793",
"0.64688575",
"0.6412785",
"0.6410566",
"0.637989",
"0.6376321",
"0.63263226",
"0.6301394",
"0.6280836",
"0.62782186",
"0.6134096",
"0.61190915",
"0.6102165",
"0.6091341",
"0.6078036",
"0.60745895",
"0.59728205",
"0.5969861",
"0.5958944",
"0.58879626",
"0.584863... | 0.6674132 | 0 |
Perform a bitwise get int op. | def test_bit_get_int(self):
ops = [bitwise_operations.bit_get_int(self.five_255_bin, 0, 8, False)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = 255
assert result["255"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int_accross_bytes(self):\n ops = [bitwise_operations.bit_get_int(self.test_bin_ones, 4, 8, False)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = 16\n assert result[\"bitwise1\"] == expected_result",
"def bitget(x, n):\n ret... | [
"0.7102906",
"0.6779233",
"0.66473794",
"0.6560103",
"0.65105355",
"0.643833",
"0.63135123",
"0.6293292",
"0.62082666",
"0.6207934",
"0.6200382",
"0.6193435",
"0.6190294",
"0.61502796",
"0.6123102",
"0.61018723",
"0.60295856",
"0.6009847",
"0.5998483",
"0.597783",
"0.59735185... | 0.72884405 | 0 |
Perform a bitwise get int op across bytes. | def test_bit_get_int_accross_bytes(self):
ops = [bitwise_operations.bit_get_int(self.test_bin_ones, 4, 8, False)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = 16
assert result["bitwise1"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int_multiple_bytes(self):\n ops = [bitwise_operations.bit_get_int(self.five_255_bin, 4, 17, False)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = 131071\n assert result[\"255\"] == expected_result",
"def getint(data, offset, i... | [
"0.71205246",
"0.70693725",
"0.69792545",
"0.6811776",
"0.66377413",
"0.66353595",
"0.6517587",
"0.6409903",
"0.6406056",
"0.62259734",
"0.61921054",
"0.6164331",
"0.61605984",
"0.6147947",
"0.6147531",
"0.6143852",
"0.6137119",
"0.6134667",
"0.60648817",
"0.60472596",
"0.602... | 0.7891104 | 0 |
Perform a bitwise get int op across multiple bytes. | def test_bit_get_int_multiple_bytes(self):
ops = [bitwise_operations.bit_get_int(self.five_255_bin, 4, 17, False)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = 131071
assert result["255"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int_accross_bytes(self):\n ops = [bitwise_operations.bit_get_int(self.test_bin_ones, 4, 8, False)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = 16\n assert result[\"bitwise1\"] == expected_result",
"def getint(data, offset, i... | [
"0.75471073",
"0.678968",
"0.65833163",
"0.6527488",
"0.6496764",
"0.63625884",
"0.6067101",
"0.59414285",
"0.5925806",
"0.5871448",
"0.58513236",
"0.5844034",
"0.5837902",
"0.5762377",
"0.5762377",
"0.57595783",
"0.5753502",
"0.56997323",
"0.568903",
"0.5688321",
"0.5682894"... | 0.75146616 | 1 |
Perform a bitwise get int with a bit_size larger than the bitmap being read. | def test_bit_get_int_bit_size_too_large(self):
ops = [bitwise_operations.bit_get_int(self.test_bin_ones, 0, 41, False)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int(self):\n ops = [bitwise_operations.bit_get_int(self.five_255_bin, 0, 8, False)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = 255\n assert result[\"255\"] == expected_result",
"def test_bit_get_int_accross_bytes(self):\n ... | [
"0.68701124",
"0.68527347",
"0.6686685",
"0.6607664",
"0.6548053",
"0.6484254",
"0.6442532",
"0.6422704",
"0.6400369",
"0.6389926",
"0.6377081",
"0.6276066",
"0.6234731",
"0.6165739",
"0.6152089",
"0.6149299",
"0.6145901",
"0.61367106",
"0.60860854",
"0.5989236",
"0.598441",
... | 0.70119935 | 0 |
Perform a bitwise get int op with sign true. | def test_bit_get_int_signed(self):
ops = [bitwise_operations.bit_get_int(self.five_255_bin, 0, 8, True)]
_, _, result = self.as_connection.operate(self.test_key, ops)
expected_result = -1
assert result["255"] == expected_result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_get_int(self):\n ops = [bitwise_operations.bit_get_int(self.five_255_bin, 0, 8, False)]\n\n _, _, result = self.as_connection.operate(self.test_key, ops)\n\n expected_result = 255\n assert result[\"255\"] == expected_result",
"def _get_bit(self, num, bit, mask=1):\n re... | [
"0.6509758",
"0.63602674",
"0.6266089",
"0.62134486",
"0.6150972",
"0.60837835",
"0.5986445",
"0.5969886",
"0.5921053",
"0.5897795",
"0.5893982",
"0.5842662",
"0.5799386",
"0.57741714",
"0.57586473",
"0.5749016",
"0.5726743",
"0.5701007",
"0.56617063",
"0.56174797",
"0.561278... | 0.7207223 | 0 |
Perform a bitwise insert op. | def test_bit_insert(self):
value = bytearray([3])
ops = [bitwise_operations.bit_insert(self.test_bin_zeroes, 0, 1, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([3] * 1 + [0] * 5)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _insert_op(self, op):",
"def test_bit_insert_multiple_bytes_with_offset(self):\n value = bytearray([3] * 3)\n ops = [bitwise_operations.bit_insert(self.test_bin_zeroes, 2, 3, value, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(sel... | [
"0.71780396",
"0.658312",
"0.65635574",
"0.63127637",
"0.6227794",
"0.61238205",
"0.6090394",
"0.59877443",
"0.5869586",
"0.58213556",
"0.57300776",
"0.56653476",
"0.5499907",
"0.5486901",
"0.54348606",
"0.5416248",
"0.53926224",
"0.5384943",
"0.53558993",
"0.5337077",
"0.533... | 0.7138453 | 1 |
Perform a bitwise insert op with multiple bytes and a non 0 offset. | def test_bit_insert_multiple_bytes_with_offset(self):
value = bytearray([3] * 3)
ops = [bitwise_operations.bit_insert(self.test_bin_zeroes, 2, 3, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = byt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_insert_multiple_bytes(self):\n value = bytearray([3] * 3)\n ops = [bitwise_operations.bit_insert(self.test_bin_zeroes, 0, 3, value, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = byte... | [
"0.7038556",
"0.65061796",
"0.64552087",
"0.6403019",
"0.60924107",
"0.60375494",
"0.6032577",
"0.5855531",
"0.5665722",
"0.5656832",
"0.55806595",
"0.5539267",
"0.54879755",
"0.54079443",
"0.5370666",
"0.53351605",
"0.53261304",
"0.52470505",
"0.51999",
"0.5158822",
"0.51491... | 0.7592493 | 0 |
Perform a bitwise insert op where byte_offset is out of range for the bitmap being modified. Places 0 untill proper offset is reached. | def test_bit_insert_offset_out_of_range(self):
value = bytearray([3])
ops = [bitwise_operations.bit_insert(self.five_255_bin, 9, 1, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([255] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_insert_multiple_bytes_with_offset(self):\n value = bytearray([3] * 3)\n ops = [bitwise_operations.bit_insert(self.test_bin_zeroes, 2, 3, value, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_r... | [
"0.6690235",
"0.60884166",
"0.60283166",
"0.5965435",
"0.58556616",
"0.5721447",
"0.5667663",
"0.5619984",
"0.55654263",
"0.55636644",
"0.5560772",
"0.55084085",
"0.5501264",
"0.5473809",
"0.54536104",
"0.53604025",
"0.5360399",
"0.5353372",
"0.535322",
"0.52948534",
"0.52939... | 0.7140981 | 0 |
Perform a bitwise insert op where value_byte_size is larger than the bitmap being modified. | def test_bit_insert_value_byte_size_too_large(self):
value = bytearray([3] * 6)
ops = [bitwise_operations.bit_insert(self.five_255_bin, 0, 6, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytear... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_insert_value_byte_size_smaller_than_value(self):\n value = bytearray([3] * 6)\n ops = [bitwise_operations.bit_insert(self.five_255_bin, 0, 2, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n exp... | [
"0.769737",
"0.6404579",
"0.6023742",
"0.59848",
"0.5913847",
"0.5910126",
"0.5844481",
"0.5764318",
"0.5716509",
"0.5664945",
"0.56231964",
"0.55951345",
"0.5508419",
"0.54928094",
"0.54876983",
"0.5483207",
"0.54789144",
"0.5427363",
"0.5410783",
"0.53932405",
"0.53805816",... | 0.7693409 | 1 |
Perform a bitwise insert op where value_byte_size is smaller than the bitmap being modified. | def test_bit_insert_value_byte_size_smaller_than_value(self):
value = bytearray([3] * 6)
ops = [bitwise_operations.bit_insert(self.five_255_bin, 0, 2, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_insert_value_byte_size_too_large(self):\n value = bytearray([3] * 6)\n ops = [bitwise_operations.bit_insert(self.five_255_bin, 0, 6, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_res... | [
"0.76244575",
"0.63715374",
"0.60700357",
"0.5990376",
"0.586666",
"0.5862846",
"0.5861409",
"0.57503796",
"0.5734948",
"0.56520027",
"0.55897146",
"0.5559917",
"0.5514823",
"0.5505976",
"0.54876494",
"0.5475704",
"0.5434488",
"0.54248905",
"0.5423369",
"0.5398629",
"0.538956... | 0.76956564 | 0 |
Perform a bitwise insert op with a non existent bin. | def test_bit_insert_nonexistent_bin_name(self):
value = bytearray([3])
ops = [bitwise_operations.bit_insert("bad_name", 0, 1, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([3])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_insert(self):\n value = bytearray([3])\n ops = [bitwise_operations.bit_insert(self.test_bin_zeroes, 0, 1, value, None)]\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([3] * 1 + [0]... | [
"0.7160326",
"0.67176193",
"0.65476626",
"0.65370536",
"0.64729404",
"0.6287796",
"0.62124634",
"0.60395765",
"0.6007725",
"0.6004442",
"0.56489205",
"0.5540966",
"0.5484066",
"0.54520464",
"0.5378718",
"0.53578687",
"0.5348499",
"0.5330858",
"0.5326471",
"0.52357227",
"0.522... | 0.7217372 | 0 |
Perform a bitwise lscan op. | def test_bit_lscan(self):
value = True
ops = [bitwise_operations.bit_lscan(self.count_bin, 32, 8, value)]
expected_value = 6
_, _, result = self.as_connection.operate(self.test_key, ops)
assert result[self.count_bin] == expected_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_lscan_across_bytes(self):\n value = False\n ops = [bitwise_operations.bit_lscan(self.test_bin_ones, 7, 8, value)]\n\n expected_value = 1\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.test_bin_ones] == expected_value",
"def tes... | [
"0.74451196",
"0.6658104",
"0.66572857",
"0.62291265",
"0.6085733",
"0.59215665",
"0.5744479",
"0.57185316",
"0.56623083",
"0.56226116",
"0.552413",
"0.55202615",
"0.5383747",
"0.53328454",
"0.5293886",
"0.5254218",
"0.52492434",
"0.51787573",
"0.51559234",
"0.51167107",
"0.5... | 0.7567064 | 0 |
Perform a bitwise lscan op with an offset that causes the scan to search multiple bytes. | def test_bit_lscan_across_bytes(self):
value = False
ops = [bitwise_operations.bit_lscan(self.test_bin_ones, 7, 8, value)]
expected_value = 1
_, _, result = self.as_connection.operate(self.test_key, ops)
assert result[self.test_bin_ones] == expected_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_lscan_offset_out_of_range(self):\n value = True\n ops = [bitwise_operations.bit_lscan(self.count_bin, 41, 8, value)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_lscan(self):\n value = True\n ... | [
"0.68065566",
"0.66702664",
"0.6243345",
"0.57021254",
"0.55683017",
"0.5430383",
"0.5321488",
"0.5251073",
"0.5233933",
"0.5192475",
"0.5176165",
"0.51449674",
"0.5064992",
"0.50226194",
"0.4990894",
"0.49202585",
"0.49196604",
"0.4917927",
"0.4847523",
"0.48157188",
"0.4772... | 0.70847696 | 0 |
Perform a bitwise lscan op with bit_offset outside bitmap.S | def test_bit_lscan_offset_out_of_range(self):
value = True
ops = [bitwise_operations.bit_lscan(self.count_bin, 41, 8, value)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_lscan_across_bytes(self):\n value = False\n ops = [bitwise_operations.bit_lscan(self.test_bin_ones, 7, 8, value)]\n\n expected_value = 1\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.test_bin_ones] == expected_value",
"def tes... | [
"0.7298933",
"0.70126724",
"0.6571719",
"0.64918786",
"0.6292112",
"0.5880076",
"0.5796156",
"0.57129705",
"0.5523732",
"0.54938674",
"0.544911",
"0.54301494",
"0.5377849",
"0.5362025",
"0.53573096",
"0.52673286",
"0.5209288",
"0.51707304",
"0.5134745",
"0.5130603",
"0.509815... | 0.7086252 | 1 |
Perform a bitwise lscan op with bit_size larger than bitmap.S | def test_bit_lscan_bit_size_too_large(self):
value = True
ops = [bitwise_operations.bit_lscan(self.test_bin_ones, 0, 41, value)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_lscan_across_bytes(self):\n value = False\n ops = [bitwise_operations.bit_lscan(self.test_bin_ones, 7, 8, value)]\n\n expected_value = 1\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.test_bin_ones] == expected_value",
"def tes... | [
"0.7305252",
"0.7233019",
"0.6309055",
"0.61403173",
"0.60514647",
"0.595394",
"0.59533376",
"0.5549568",
"0.55292",
"0.54765344",
"0.5471686",
"0.546404",
"0.54265046",
"0.54154724",
"0.5364196",
"0.5296248",
"0.52662283",
"0.5188394",
"0.51625985",
"0.51263577",
"0.5118834"... | 0.74964994 | 0 |
Perform a bitwise lshift op with offset > bitmap. | def test_bit_lshift_offset_out_of_range(self):
ops = [bitwise_operations.bit_lshift(self.test_bin_ones, 41, 8, 1, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bitwise_lshift(self, other: Any) -> ColumnOperators:\n\n return self.operate(bitwise_lshift_op, other)",
"def lshift(self, value):\n return self.clone().lshift_(value)",
"def test_bit_lshift_wrap(self):\n ops = [bitwise_operations.bit_lshift(self.test_bin_ones, 0, 40, 8, None)]\n\n ... | [
"0.69308263",
"0.66388756",
"0.65359557",
"0.6450406",
"0.6376182",
"0.63319093",
"0.6328476",
"0.62932926",
"0.6225093",
"0.61923605",
"0.6165442",
"0.6009935",
"0.59374416",
"0.59149414",
"0.590938",
"0.5865252",
"0.5850488",
"0.5823703",
"0.5793596",
"0.57894117",
"0.56782... | 0.667068 | 1 |
Perform a bitwise lshift op with bit_size > bitmap. | def test_bit_lshift_bit_size_too_large(self):
ops = [bitwise_operations.bit_lshift(self.test_bin_ones, 0, 41, 1, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_lshift_wrap(self):\n ops = [bitwise_operations.bit_lshift(self.test_bin_ones, 0, 40, 8, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([1] * 4 + [0])\n assert bins[self.te... | [
"0.6950515",
"0.6931721",
"0.6767711",
"0.67303616",
"0.6553696",
"0.64958674",
"0.6486794",
"0.6405344",
"0.6370063",
"0.6367465",
"0.61931336",
"0.61865187",
"0.6111606",
"0.59819406",
"0.5948448",
"0.5942128",
"0.59374654",
"0.59374654",
"0.5933737",
"0.5898842",
"0.587550... | 0.7226745 | 0 |
Perform a bitwise not op with a bit_size > bitmap. | def test_bit_not_bit_size_too_large(self):
ops = [bitwise_operations.bit_not(self.five_255_bin, 0, 41, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bitwise_not(data):\n return _make.bitwise_not(data)",
"def NOT(bmp):\n\n maxX, maxY = size = bmp.size()\n result = bitmap(size)\n for x in range(maxX):\n for y in range(maxY):\n result.set(x,y, not bmp.get(x,y))\n return result",
"def test_bit_not_small_bit_size(self):\n ... | [
"0.7226076",
"0.72110623",
"0.70213264",
"0.7011794",
"0.6715211",
"0.6617093",
"0.62654257",
"0.62304515",
"0.62099355",
"0.6074832",
"0.60745364",
"0.6057515",
"0.605546",
"0.6027605",
"0.59840214",
"0.58479655",
"0.5844934",
"0.5838357",
"0.5771804",
"0.57580274",
"0.56813... | 0.7249606 | 0 |
Perform a bitwise or op on multiple bytes. | def test_bit_or_multiple_bytes(self):
value = bytearray([8] * 5)
ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 40, 5, value, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([9] * 5)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bitwise_or(self):\n register = self.return_middle_registers(self.opcode)\n self.registers[register[0]] = (\n self.registers[register[0]] | self.registers[register[1]])\n logger.info(\"Bitwise OR on V{} and V{} for {}\".format(\n register[0],\n register[1],\... | [
"0.7118076",
"0.6908915",
"0.68121326",
"0.67484117",
"0.6612568",
"0.64334434",
"0.63509226",
"0.62192816",
"0.61630046",
"0.61462665",
"0.6096318",
"0.60574114",
"0.6025009",
"0.6018953",
"0.5995515",
"0.5988682",
"0.59162784",
"0.5895464",
"0.58875316",
"0.586352",
"0.5814... | 0.7336967 | 0 |
Perform a bitwise or op with bit_offset > bitmap. | def test_bit_or_bit_offset_out_of_range(self):
value = bytearray()
value.append(8)
ops = [bitwise_operations.bit_or(self.test_bin_ones, 41, 8, 1, value, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_or(self):\n value = bytearray()\n value.append(8)\n ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 8, 1, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytear... | [
"0.6729167",
"0.6678208",
"0.65645045",
"0.6495425",
"0.6474674",
"0.64089435",
"0.61538225",
"0.61365926",
"0.6038137",
"0.59736896",
"0.5905584",
"0.5881746",
"0.57951003",
"0.5723682",
"0.570876",
"0.5666415",
"0.56518066",
"0.5618289",
"0.55157775",
"0.54992855",
"0.54678... | 0.6939254 | 0 |
Perform a bitwise or op with bit_size > value. | def test_bit_or_bit_size_larger_than_value(self):
value = bytearray()
value.append(8)
ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 9, 1, value, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_or_bit_size_too_large(self):\n value = bytearray([8] * 6)\n ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 41, 6, value, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_or_bit_offset_out_of_ra... | [
"0.7268937",
"0.64769953",
"0.6328302",
"0.61380446",
"0.6119461",
"0.60546505",
"0.60256964",
"0.5878146",
"0.58711094",
"0.58374584",
"0.5796204",
"0.57682717",
"0.57471216",
"0.57353663",
"0.5596316",
"0.55628544",
"0.5561486",
"0.5496804",
"0.54590476",
"0.5422026",
"0.54... | 0.7830411 | 0 |
Perform a bitwise or op with bit_size > bitmap. | def test_bit_or_bit_size_too_large(self):
value = bytearray([8] * 6)
ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 41, 6, value, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_or_bit_size_larger_than_value(self):\n value = bytearray()\n value.append(8)\n ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 9, 1, value, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit... | [
"0.6960213",
"0.66661066",
"0.65235865",
"0.64447516",
"0.6371661",
"0.6339229",
"0.6302238",
"0.6228568",
"0.6185054",
"0.58057094",
"0.5755791",
"0.5741155",
"0.57355267",
"0.56997937",
"0.56335616",
"0.5625084",
"0.56033003",
"0.5583323",
"0.5559221",
"0.5544787",
"0.54311... | 0.71554786 | 0 |
Perform a bitwise or op with a non existent bin. | def test_bit_or_bad_bin_name(self):
value = bytearray([8])
ops = [bitwise_operations.bit_or("bad_name", 0, 8, 1, value, None)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_or(self):\n value = bytearray()\n value.append(8)\n ops = [bitwise_operations.bit_or(self.test_bin_ones, 0, 8, 1, value, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytear... | [
"0.7058968",
"0.68445206",
"0.6766226",
"0.6755977",
"0.66884106",
"0.6688318",
"0.662055",
"0.6593961",
"0.6555172",
"0.65347177",
"0.64945513",
"0.6492931",
"0.6429049",
"0.6394153",
"0.63550234",
"0.6181719",
"0.61228025",
"0.61127645",
"0.6107482",
"0.60979706",
"0.608336... | 0.7370496 | 0 |
Perform a bitwise rscan op. | def test_bit_rscan(self):
value = True
ops = [bitwise_operations.bit_rscan(self.count_bin, 32, 8, value)]
expected_value = 7
_, _, result = self.as_connection.operate(self.test_key, ops)
assert result[self.count_bin] == expected_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_rscan_across_bytes(self):\n value = False\n ops = [bitwise_operations.bit_rscan(self.count_bin, 4, 8, value)]\n\n expected_value = 6\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.count_bin] == expected_value",
"def test_bit_rs... | [
"0.74822855",
"0.6734437",
"0.6538638",
"0.6246549",
"0.62174636",
"0.6194373",
"0.618414",
"0.607976",
"0.59486955",
"0.57588637",
"0.5621344",
"0.5594654",
"0.5458126",
"0.52684414",
"0.5247702",
"0.51422316",
"0.51344895",
"0.51321477",
"0.5124892",
"0.5113414",
"0.5090413... | 0.75062853 | 0 |
Perform a bitwise rscan op with an offset that causes the scan to search multiple bytes. | def test_bit_rscan_across_bytes(self):
value = False
ops = [bitwise_operations.bit_rscan(self.count_bin, 4, 8, value)]
expected_value = 6
_, _, result = self.as_connection.operate(self.test_key, ops)
assert result[self.count_bin] == expected_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_rscan_offset_out_of_range(self):\n value = True\n ops = [bitwise_operations.bit_rscan(self.count_bin, 41, 8, value)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_rscan(self):\n value = True\n ... | [
"0.65359974",
"0.62749314",
"0.61366034",
"0.5726591",
"0.56616104",
"0.5530678",
"0.53169584",
"0.525473",
"0.52101773",
"0.51923454",
"0.5138028",
"0.51262224",
"0.5119742",
"0.5088162",
"0.5071134",
"0.5071134",
"0.5028353",
"0.49690193",
"0.4927765",
"0.49174833",
"0.4893... | 0.68539107 | 0 |
Perform a bitwise rscan op with bit_offset outside bitmap. | def test_bit_rscan_offset_out_of_range(self):
value = True
ops = [bitwise_operations.bit_rscan(self.count_bin, 41, 8, value)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_rscan_across_bytes(self):\n value = False\n ops = [bitwise_operations.bit_rscan(self.count_bin, 4, 8, value)]\n\n expected_value = 6\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.count_bin] == expected_value",
"def test_bit_rs... | [
"0.67986",
"0.66038847",
"0.6403984",
"0.6318248",
"0.599119",
"0.5979703",
"0.54372746",
"0.5428746",
"0.53934145",
"0.5282545",
"0.5277166",
"0.51844627",
"0.5067494",
"0.5055215",
"0.4952921",
"0.49221352",
"0.4920336",
"0.48970672",
"0.4873152",
"0.48365533",
"0.47873604"... | 0.7030813 | 0 |
Perform a bitwise rscan op with bit_size larger than bitmap. | def test_bit_rscan_bit_size_too_large(self):
value = True
ops = [bitwise_operations.bit_rscan(self.test_bin_ones, 0, 41, value)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_rscan_across_bytes(self):\n value = False\n ops = [bitwise_operations.bit_rscan(self.count_bin, 4, 8, value)]\n\n expected_value = 6\n _, _, result = self.as_connection.operate(self.test_key, ops)\n assert result[self.count_bin] == expected_value",
"def test_bit_rs... | [
"0.69535387",
"0.67778087",
"0.6079555",
"0.5970527",
"0.56409127",
"0.5558105",
"0.5542117",
"0.5486178",
"0.5464228",
"0.5384822",
"0.5123307",
"0.5029938",
"0.49641097",
"0.49303055",
"0.49159634",
"0.4879424",
"0.47828934",
"0.4773927",
"0.47594815",
"0.46685913",
"0.4661... | 0.73615736 | 0 |
Perform a bitwise rshift op with offset > bitmap. | def test_bit_rshift_offset_out_of_range(self):
ops = [bitwise_operations.bit_rshift(self.test_bin_ones, 41, 8, 1, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bitwise_rshift(self, other: Any) -> ColumnOperators:\n\n return self.operate(bitwise_rshift_op, other)",
"def test_bit_rshift_wrap(self):\n ops = [bitwise_operations.bit_rshift(self.test_bin_ones, 0, 40, 8, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins =... | [
"0.68082476",
"0.6507718",
"0.6502205",
"0.6427334",
"0.6422783",
"0.6422783",
"0.6422021",
"0.64078856",
"0.6404838",
"0.63749677",
"0.62379384",
"0.6169324",
"0.6154082",
"0.61445355",
"0.61361104",
"0.60724884",
"0.6042694",
"0.60101116",
"0.5978205",
"0.59142226",
"0.5843... | 0.6681683 | 1 |
Perform a bitwise rshift op with bit_size > bitmap. | def test_bit_rshift_bit_size_too_large(self):
ops = [bitwise_operations.bit_rshift(self.test_bin_ones, 0, 41, 1, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_rshift_wrap(self):\n ops = [bitwise_operations.bit_rshift(self.test_bin_ones, 0, 40, 8, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = bytearray([0] + [1] * 4)\n assert bins[self.te... | [
"0.6985838",
"0.6975781",
"0.6904481",
"0.6876606",
"0.6723617",
"0.6723617",
"0.64922476",
"0.6429139",
"0.6359374",
"0.63542265",
"0.6311663",
"0.62846226",
"0.6275696",
"0.6140997",
"0.6140134",
"0.60402584",
"0.60362566",
"0.60202444",
"0.5996184",
"0.5978953",
"0.5953361... | 0.73658377 | 0 |
Perform a bitwise subtract op with an offset that lands inbetween bytes. | def test_bit_subtract_inbetween_bytes(self):
ops = [bitwise_operations.bit_subtract(self.five_255_bin, 4, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([24... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_subtract_bit_offset_out_of_range(self):\n ops = [\n bitwise_operations.bit_subtract(self.test_bin_zeroes, 41, 1, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)\n ]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"... | [
"0.64977556",
"0.62412834",
"0.6239557",
"0.62195957",
"0.6215681",
"0.618028",
"0.59770906",
"0.5848042",
"0.5848042",
"0.5848042",
"0.58252114",
"0.5815021",
"0.5802187",
"0.5801449",
"0.5796449",
"0.5793272",
"0.5781425",
"0.5732522",
"0.5732522",
"0.57230633",
"0.5714507"... | 0.6829426 | 0 |
Perform a bitwise subtract op with multiple bytes. | def test_bit_subtract_multiple_bytes(self):
ops = [
bitwise_operations.bit_subtract(self.test_bin_ones, 8, 16, 257, False, aerospike.BIT_OVERFLOW_FAIL, None)
]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_subtract_inbetween_bytes(self):\n ops = [bitwise_operations.bit_subtract(self.five_255_bin, 4, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n self.as_connection.operate(self.test_key, ops)\n\n _, _, bins = self.as_connection.get(self.test_key)\n expected_result = by... | [
"0.7051683",
"0.6489156",
"0.6265554",
"0.62049377",
"0.6195712",
"0.61772144",
"0.61772144",
"0.60979056",
"0.60612816",
"0.6039638",
"0.6035834",
"0.6015598",
"0.5974205",
"0.59607345",
"0.5958435",
"0.58393854",
"0.58328086",
"0.5803468",
"0.579507",
"0.5792536",
"0.579253... | 0.75186557 | 0 |
Perform a bitwise subtract op on a nonexistent bin. | def test_bit_subtract_bad_bin_name(self):
ops = [bitwise_operations.bit_subtract("bad_name", 8, 16, 257, False, aerospike.BIT_OVERFLOW_FAIL, None)]
with pytest.raises(e.BinNotFound):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_subtract_overflow_fail(self):\n ops = [bitwise_operations.bit_subtract(self.test_bin_ones, 0, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_subtract_simple(self):... | [
"0.6932047",
"0.68951654",
"0.68864524",
"0.68545467",
"0.68055755",
"0.668892",
"0.6510099",
"0.64084166",
"0.628363",
"0.62496334",
"0.6238307",
"0.6140046",
"0.6119843",
"0.6021742",
"0.5957144",
"0.5939512",
"0.5780383",
"0.5756103",
"0.56450284",
"0.56420887",
"0.5607923... | 0.78149927 | 0 |
Perform a bitwise subtract op with a bit_offset that is out of range for the bitmap being modified. | def test_bit_subtract_bit_offset_out_of_range(self):
ops = [
bitwise_operations.bit_subtract(self.test_bin_zeroes, 41, 1, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)
]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_remove_offset_out_of_range(self):\n ops = [bitwise_operations.bit_remove(self.test_bin_zeroes, 6, 1, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_subtract_bit_size_out_of_range(self):\n ops = [\n ... | [
"0.68870574",
"0.6712617",
"0.66374624",
"0.6593059",
"0.6452417",
"0.6321592",
"0.6146227",
"0.6096179",
"0.6046044",
"0.5997577",
"0.59970427",
"0.5973413",
"0.59491795",
"0.5849707",
"0.57583743",
"0.57313645",
"0.5667159",
"0.5593854",
"0.55748856",
"0.55695486",
"0.55690... | 0.743607 | 0 |
Perform a bitwise subtract op that overflows with the BIT_OVERFLOW_FAIL action. | def test_bit_subtract_overflow_fail(self):
ops = [bitwise_operations.bit_subtract(self.test_bin_ones, 0, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_subtract_bit_offset_out_of_range(self):\n ops = [\n bitwise_operations.bit_subtract(self.test_bin_zeroes, 41, 1, 1, False, aerospike.BIT_OVERFLOW_FAIL, None)\n ]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"... | [
"0.7370349",
"0.7360217",
"0.67168427",
"0.66955477",
"0.6690933",
"0.6342002",
"0.63284343",
"0.62131953",
"0.6136948",
"0.6106323",
"0.60354006",
"0.595727",
"0.590616",
"0.58953905",
"0.58631927",
"0.58592397",
"0.58166087",
"0.5726038",
"0.5701894",
"0.56896704",
"0.56878... | 0.819887 | 0 |
Perform a bitwise subtract op that overflows with the BIT_OVERFLOW_SATURATE action. | def test_bit_subtract_overflow_saturate(self):
ops = [
bitwise_operations.bit_subtract(self.test_bin_ones, 0, 8, 255, False, aerospike.BIT_OVERFLOW_SATURATE, None)
]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
ex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_subtract_overflow_fail(self):\n ops = [bitwise_operations.bit_subtract(self.test_bin_ones, 0, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_subtract_bit_offset_ou... | [
"0.726783",
"0.6864169",
"0.67772174",
"0.67653507",
"0.67579377",
"0.6566348",
"0.61904657",
"0.6066806",
"0.59181464",
"0.57647073",
"0.57319677",
"0.57319677",
"0.5728272",
"0.56917715",
"0.56846565",
"0.5678812",
"0.56218684",
"0.5600619",
"0.5527363",
"0.5527363",
"0.552... | 0.72179174 | 1 |
Perform a bitwise subtract op that overflows with the BIT_OVERFLOW_WRAP action. | def test_bit_subtract_overflow_wrap(self):
ops = [bitwise_operations.bit_subtract(self.five_255_bin, 0, 8, 1, False, aerospike.BIT_OVERFLOW_WRAP, None)]
self.as_connection.operate(self.test_key, ops)
_, _, bins = self.as_connection.get(self.test_key)
expected_result = bytearray([254] *... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_subtract_overflow_fail(self):\n ops = [bitwise_operations.bit_subtract(self.test_bin_ones, 0, 8, 255, False, aerospike.BIT_OVERFLOW_FAIL, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_subtract_bit_size_out_... | [
"0.71338594",
"0.63404083",
"0.6331683",
"0.6260237",
"0.625121",
"0.61504817",
"0.6129522",
"0.60416776",
"0.56835353",
"0.5678757",
"0.56779814",
"0.5620698",
"0.55475885",
"0.55475885",
"0.5547116",
"0.5539497",
"0.54920566",
"0.5421593",
"0.5421593",
"0.5421593",
"0.53716... | 0.7361038 | 0 |
Perform a bitwise xor op with bit_offset > bitmap. | def test_bit_xor_bit_offset_out_of_range(self):
value = bytearray()
value.append(8)
ops = [bitwise_operations.bit_xor(self.test_bin_ones, 41, 8, 1, value, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_xor_with_policy(self):\n value = bytearray([0])\n bit_policy = {\n \"bit_write_flags\": aerospike.BIT_WRITE_UPDATE_ONLY,\n }\n ops = [bitwise_operations.bit_xor(self.test_bin_zeroes, 7, 8, 1, value, bit_policy)]\n\n self.as_connection.operate(self.test_key... | [
"0.65985656",
"0.65077275",
"0.6500673",
"0.6443339",
"0.6437669",
"0.63780266",
"0.6351648",
"0.6344364",
"0.6307836",
"0.62951785",
"0.62089914",
"0.6118041",
"0.6113544",
"0.6078223",
"0.5945127",
"0.59304786",
"0.58627397",
"0.5844661",
"0.5823797",
"0.57821214",
"0.57653... | 0.67272615 | 0 |
Perform a bitwise xor op with bit_size > value. | def test_bit_xor_bit_size_larger_than_value(self):
value = bytearray()
value.append(8)
ops = [bitwise_operations.bit_xor(self.test_bin_ones, 0, 9, 1, value, None)]
with pytest.raises(e.InvalidRequest):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_xor_bit_size_too_large(self):\n value = bytearray([8] * 6)\n ops = [bitwise_operations.bit_xor(self.test_bin_ones, 0, 41, 6, value, None)]\n\n with pytest.raises(e.OpNotApplicable):\n self.as_connection.operate(self.test_key, ops)",
"def test_bit_xor_with_policy(self)... | [
"0.73067886",
"0.6601729",
"0.64713144",
"0.63067836",
"0.6222421",
"0.6178869",
"0.60622954",
"0.6051137",
"0.5981829",
"0.58503556",
"0.58304",
"0.57703584",
"0.57439303",
"0.57016945",
"0.5671008",
"0.5643629",
"0.56371194",
"0.56351",
"0.5610179",
"0.5597002",
"0.5594237"... | 0.7796739 | 0 |
Perform a bitwise xor op with bit_size > bitmap. | def test_bit_xor_bit_size_too_large(self):
value = bytearray([8] * 6)
ops = [bitwise_operations.bit_xor(self.test_bin_ones, 0, 41, 6, value, None)]
with pytest.raises(e.OpNotApplicable):
self.as_connection.operate(self.test_key, ops) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bit_xor_bit_size_larger_than_value(self):\n value = bytearray()\n value.append(8)\n ops = [bitwise_operations.bit_xor(self.test_bin_ones, 0, 9, 1, value, None)]\n\n with pytest.raises(e.InvalidRequest):\n self.as_connection.operate(self.test_key, ops)",
"def test_b... | [
"0.6650416",
"0.6514225",
"0.6504798",
"0.64670455",
"0.63607264",
"0.6328545",
"0.62608737",
"0.6258549",
"0.62444615",
"0.6225799",
"0.6198831",
"0.6184471",
"0.61594546",
"0.6144056",
"0.61243796",
"0.6093759",
"0.5990066",
"0.5982106",
"0.5820446",
"0.58060426",
"0.579869... | 0.6932577 | 0 |
Perform a bitwise xor op with a policy. | def test_bit_xor_with_policy(self):
value = bytearray([0])
bit_policy = {
"bit_write_flags": aerospike.BIT_WRITE_UPDATE_ONLY,
}
ops = [bitwise_operations.bit_xor(self.test_bin_zeroes, 7, 8, 1, value, bit_policy)]
self.as_connection.operate(self.test_key, ops)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xor(a, b):",
"def xor(self, *args):\n return Xor(self, *args)",
"def bitwise_xor(lhs, rhs):\n return _make.bitwise_xor(lhs, rhs)",
"def logical_xor(lhs, rhs):\n return _make.logical_xor(lhs, rhs)",
"def convert_broadcast_logical_xor(node, **kwargs):\n return create_basic_op_node('Xor', ... | [
"0.70831174",
"0.70623076",
"0.7059884",
"0.6676336",
"0.6656898",
"0.664496",
"0.66145754",
"0.64989746",
"0.6422519",
"0.6372238",
"0.6363608",
"0.6344332",
"0.63420236",
"0.6274215",
"0.6215274",
"0.6188354",
"0.61743647",
"0.6155858",
"0.61499715",
"0.6121868",
"0.6027265... | 0.7542527 | 0 |
Attempts to find a candidate layer to use for CAM extraction | def locate_candidate_layer(mod: nn.Module, input_shape: Tuple[int, ...] = (3, 224, 224)) -> Optional[str]:
# Set module in eval mode
module_mode = mod.training
mod.eval()
output_shapes: List[Tuple[Optional[str], Tuple[int, ...]]] = []
def _record_output_shape(module: nn.Module, input: Tensor, outp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_CA_layer(arch, target_layer_name):\n\n hierarchy = target_layer_name.rsplit(\"_\",1)\n \n\n if target_layer_name == \"layer1\":\n return arch.layer1\n elif target_layer_name == \"layer2\":\n return arch.layer2\n elif target_layer_name == \"layer3\":\n return arch.layer3... | [
"0.62724084",
"0.6052908",
"0.5938766",
"0.5923088",
"0.58682144",
"0.5823416",
"0.5793721",
"0.5652858",
"0.56480765",
"0.5600004",
"0.55514055",
"0.55042034",
"0.5492678",
"0.54090405",
"0.53978735",
"0.53533643",
"0.53379434",
"0.5288922",
"0.52618504",
"0.5260588",
"0.524... | 0.6229697 | 1 |
Returns the asset with the given id. | def get_asset(self, asset_id):
text, code = ApiClient(self._config, 'assets/' + asset_id).get()
return Asset.deserialize(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_asset(self, asset_id):\n endpoint = '/assets/{}'.format(asset_id)\n return self._api_call('get', endpoint)",
"def asset(self, asset_id):\n headers, items = self._get('/asset/%s' % asset_id)\n return Asset.fromdict(items[0], api=self, full=True)",
"def get_asset(self, asset_id, asset... | [
"0.86297536",
"0.8100816",
"0.7962342",
"0.7741411",
"0.74044025",
"0.7134656",
"0.7062719",
"0.7001603",
"0.68088776",
"0.67893684",
"0.6752635",
"0.6658891",
"0.6634489",
"0.6628158",
"0.6605129",
"0.66020226",
"0.6591007",
"0.6567516",
"0.6552751",
"0.6544386",
"0.6536535"... | 0.85032684 | 1 |
Obtains Marketplace object given its ID. | def get_marketplace(self, marketplace_id):
return MarketplaceResource(self._config).get(marketplace_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_place_by_id(id):\n rv = query_db('select * from places where place_id = ?',\n [id])\n return rv[0] if rv else None",
"def get_object(self, id_):\n return self._objects.get(id_, None)",
"def get_place_by_id(place_id):\n place_obj = storage.get(\"Place\", place_id)\n i... | [
"0.6927319",
"0.6671522",
"0.664275",
"0.66377103",
"0.662131",
"0.6612834",
"0.6585188",
"0.65535146",
"0.64867014",
"0.6379136",
"0.6267908",
"0.62560844",
"0.61420566",
"0.61420566",
"0.6021101",
"0.6012841",
"0.60083824",
"0.59366053",
"0.592935",
"0.59106505",
"0.590253"... | 0.78990203 | 0 |
List the tier configs. | def list_tier_configs(self, filters=None):
query = self._get_filters_query(filters, True)
text, code = ApiClient(self._config, 'tier/configs' + query.compile()).get()
return TierConfig.deserialize(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def getTiers(self, ctx):\n server_dict = self.get_server_dict(ctx)\n tierList = server_dict.setdefault(\"Tiers\", [])\n\n if(len(tierList) > 0):\n await self.bot.say(\"Tiers:\")\n for tier in tierList:\n await self.bot.say(tier)\n else:\n ... | [
"0.6430079",
"0.6417699",
"0.6046109",
"0.59574795",
"0.5842776",
"0.5786352",
"0.5761368",
"0.5682218",
"0.56768256",
"0.56768256",
"0.56768256",
"0.56163913",
"0.55981684",
"0.5581887",
"0.55486715",
"0.54345995",
"0.53955334",
"0.53955334",
"0.53955334",
"0.53955334",
"0.5... | 0.7024054 | 0 |
Returns the tier config with the given id. | def get_tier_config(self, tier_config_id):
text, code = ApiClient(self._config, 'tier/configs/' + tier_config_id).get()
return TierConfig.deserialize(text) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_tier(pkmn_id):\n if pkmn_id in tiers.TIERS[\"0\"]:\n return 0\n elif pkmn_id in tiers.TIERS[\"1\"]:\n return 1\n elif pkmn_id in tiers.TIERS[\"2\"]:\n return 2\n elif pkmn_id in tiers.TIERS[\"3\"]:\n return 3\n else:\n return 4",
"def get_tenant_config(t... | [
"0.6171392",
"0.6161959",
"0.6053528",
"0.58012205",
"0.56873274",
"0.5458873",
"0.54341584",
"0.54274875",
"0.54274875",
"0.54274875",
"0.54274875",
"0.54111546",
"0.54089653",
"0.53808326",
"0.53808326",
"0.53808326",
"0.5372766",
"0.53144056",
"0.5300942",
"0.5277725",
"0.... | 0.8059733 | 0 |
Property for the event description based on the code | def event_desc(self) -> str:
return _EVENT_DESC_MAPPINGS.get(self.transaction_event_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_interesting_event_description(self):\n pass",
"def new_desc_event(self, event):\r\n pass",
"def get_description(self, code):\n try:\n return self.message[str(code)]\n except KeyError:\n return \"Unknown (\" + str(code) + \")\"",
"def event_for_event_descr... | [
"0.7521428",
"0.71878743",
"0.7116342",
"0.6826529",
"0.6817979",
"0.67542845",
"0.6681775",
"0.6681775",
"0.6652655",
"0.6632184",
"0.6632184",
"0.6611476",
"0.65897524",
"0.6565737",
"0.65504605",
"0.65504605",
"0.65504605",
"0.65266895",
"0.65266895",
"0.65266895",
"0.6498... | 0.807602 | 0 |
Property for the enumeration of this transaction () | def transaction_status_enum(self) -> TransactionStatus:
return _TRANSACTION_STATUS_MAPPING.get(self.transaction_status) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enum(self):\r\n raise NotImplementedError",
"def enumeration(self):\n raise exceptions.NotImplementedError()",
"def __index__(cls): # pylint: disable=invalid-index-returned\n return TransType(60)",
"def attr(self):\n\n return EnumAttr(self)",
"def natural_key(self):\n\t\tse... | [
"0.71118397",
"0.6270592",
"0.62465674",
"0.6158069",
"0.59486014",
"0.58366627",
"0.58330446",
"0.58252573",
"0.5776557",
"0.5740692",
"0.57314277",
"0.5705731",
"0.5659605",
"0.565769",
"0.5623061",
"0.56176597",
"0.56176597",
"0.561505",
"0.561505",
"0.5612701",
"0.5606627... | 0.6593331 | 1 |
Build the queryset's menu nodes | def queryset_nodes(queryset):
for article in queryset:
article_nodes.append(NavigationNode(
article.title,
aritcle.url,
article.menu.menuid,
article.menu.parent,
)
)
return article_nodes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_menus( self ):",
"def create_all_menus(self, ):\n m = self._model\n if not m:\n return\n indizes = self._flatten_hierarchy(m)\n for i in indizes:\n self.create_menu_for_index(i)",
"def menu(self):\n menu = list()\n \n \n menu.extend([\n ... | [
"0.6887437",
"0.6695563",
"0.65804785",
"0.6051546",
"0.6004562",
"0.6000519",
"0.60000986",
"0.5959026",
"0.5901801",
"0.58684534",
"0.5846643",
"0.58404493",
"0.5832597",
"0.58244693",
"0.58063537",
"0.57588434",
"0.57193357",
"0.5719219",
"0.5705354",
"0.5689959",
"0.56385... | 0.734222 | 0 |
returns the list of products that is visible to the given account | def get_visible_products(self):
all_products = billing.loading.get_products(hidden=True)
public_products = billing.loading.get_products()
subscribed_product_types = ProductType.objects \
.filter(subscriptions__billing_account=self) \
.distinct()
subscribed... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def see_products_for_rent_handler():\n\n products = ShowProductsAndCustomers()\n my_list = products.see_products_for_rent()\n my_result_list = []\n for product in my_list:\n my_result_list.append(product)\n print(product)\n return my_result_list",
"def get_vendors_and_products_seen(c... | [
"0.61855996",
"0.6172926",
"0.59688145",
"0.5910303",
"0.5864358",
"0.5848761",
"0.58424187",
"0.58332884",
"0.5669318",
"0.5644832",
"0.56349075",
"0.5614921",
"0.56030047",
"0.55888885",
"0.55652934",
"0.55594563",
"0.5548453",
"0.5529825",
"0.55008173",
"0.54984933",
"0.54... | 0.7699004 | 0 |
returns the subscriptions whose most recent status is one of those specified | def filter_by_current_statuses(self, statuses):
annotated = self.annotate(
newest=models.Max('approval_statuses__created'))
newest_subs = annotated.filter(
approval_statuses__created=models.F('newest'),
approval_statuses__status__in=statuses
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_by_current_status(self, status):\r\n return self.filter_by_current_statuses([status])",
"def get_latest_statuses(self):\n self.status_lock.acquire()\n status = copy.deepcopy(self.cached_status)\n self.status_lock.release()\n return status",
"def latest_payment(owne... | [
"0.5411569",
"0.5321596",
"0.53178895",
"0.5255911",
"0.51426303",
"0.50995034",
"0.50858927",
"0.5026834",
"0.4995144",
"0.4961031",
"0.49494302",
"0.49330226",
"0.4916144",
"0.48843575",
"0.48827955",
"0.48712513",
"0.4863807",
"0.48464385",
"0.48384252",
"0.4829559",
"0.48... | 0.641309 | 0 |
If the billing account already has an IOU account, return the update form. If there isn't an account yet, then return the creation form | def get_billing_details_form(billing_account):
try:
iou_account = billing_account.simple_processor_iou_account
return IOUAccountUpdateForm
except IOUAccount.DoesNotExist:
return IOUAccountCreationForm | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def manage():\n if current_user.is_agency:\n form = ManageAgencyUserAccountForm(user=current_user)\n else:\n form = ManageUserAccountForm(user=current_user)\n\n if request.method == \"POST\":\n if form.validate_on_submit():\n update_openrecords_user(form)\n redir... | [
"0.6070687",
"0.6037547",
"0.5988173",
"0.5983497",
"0.5789755",
"0.57439816",
"0.56556976",
"0.563131",
"0.5623569",
"0.5617682",
"0.5516923",
"0.54676425",
"0.5454282",
"0.54209024",
"0.5419233",
"0.5396492",
"0.53896946",
"0.53603184",
"0.5337848",
"0.52935314",
"0.5287341... | 0.7438349 | 0 |
`sender` is the subscription instance requiring approval | def do_subscription_approval(sender, **kwargs):
req_payment = sender.get_product_class().get_requires_payment_details()
if not req_payment or has_valid_billing_details(sender.billing_account):
status = 'approved'
else:
status = 'declined'
sender.set_current_approval_status(status)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save(self):\n owner = self.context[\"request\"].user\n recipient = self._recipient_email_inst.user\n\n logger.info(\n \"Transferring subscription %r from user %r to user %r\",\n owner.know_me_subscription,\n owner.pk,\n recipient.pk,\n )\n... | [
"0.64126",
"0.6349764",
"0.6349764",
"0.6349764",
"0.6021129",
"0.6001644",
"0.5986496",
"0.59361017",
"0.59361017",
"0.59361017",
"0.59361017",
"0.59361017",
"0.59173584",
"0.58232635",
"0.58184",
"0.581205",
"0.580477",
"0.58026046",
"0.5777631",
"0.57491696",
"0.5715194",
... | 0.6396265 | 1 |
returns a function to conditionally dispatch a view based on a user's current subscription status If the user is already subscribed to the plan, dispatch the current_subscription_view If the plan requires billing details, and the user doesn't have billing details on file (as reported by the processor), then dispatch th... | def subscription_view(
current_subscription_view=CurrentSubscriptionView.as_view(),
billing_details_view=SubscriptionBillingDetailsView.as_view(),
confirmation_view=SubscriptionConfirmationView.as_view(),
):
def dispatch(request, *args, **kwargs):
cur_product_cls = request.user.billing_acc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subscription_purchase(request):\n if request.method==\"POST\":\n # POST request means user submitted Stripe card form\n if \"stripeToken\" in request.POST:\n try:\n customer = stripe.Charge.create(\n amount = 60*100,\n currency = ... | [
"0.5515831",
"0.5395123",
"0.539442",
"0.5309995",
"0.5069644",
"0.50552225",
"0.5021062",
"0.50068426",
"0.49595723",
"0.49220333",
"0.48865813",
"0.48719206",
"0.4826401",
"0.47936228",
"0.47907218",
"0.4754648",
"0.4741204",
"0.47088012",
"0.46711046",
"0.4648662",
"0.4637... | 0.7740026 | 0 |
Takes a Nx9 prediction matrix, and a NxK prediction matrices of a subclassifier the subclassifier classifies only the classes in the subclasses list then, it combines the two predictions, and returns the new prediction matrix copyPred means that the prediction matrix will be copied, which costs more memory by default, ... | def combinePredictions(predictions, subpredictions, subclasses = [2,3], copyPred = False):
assert len(subclasses) == np.shape(subpredictions)[1]
assert np.shape(subpredictions)[1] < np.shape(predictions)[1]
assert np.shape(subpredictions)[0] == np.shape(predictions)[0]
if copyPred:
predicti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _multiclass_confusion_matrix_update(preds: Tensor, target: Tensor, num_classes: int) ->Tensor:\n unique_mapping = target * num_classes + preds\n bins = _bincount(unique_mapping, minlength=num_classes ** 2)\n return bins.reshape(num_classes, num_classes)",
"def process_predictions(self, predictions, ... | [
"0.6202629",
"0.56319284",
"0.55949056",
"0.5581213",
"0.55317783",
"0.55251276",
"0.55228347",
"0.5518485",
"0.55066335",
"0.5490606",
"0.5483566",
"0.5453201",
"0.54506636",
"0.5432664",
"0.5418056",
"0.54165256",
"0.5387387",
"0.53693783",
"0.5364137",
"0.53587484",
"0.535... | 0.76767987 | 0 |
Gets training data for classification, from only the given classes Either filter existing data, or load the default training data, and filter that. If either train_data or true_classes is None, the data will be loaded using get_training_data() from utils.loading | def getSubClassifierData(subclasses = [2,3], train_data = None, true_classes = None):
if (train_data is None) or (true_classes is None):
train_data, true_classes, _ = get_training_data()
assert len(true_classes) == np.shape(train_data)[0]
validsample = np.array([x in subclasses for x in true_c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_training_data(\n self,\n train_data_file=\"datasets/train_data.json\",\n test_data_file=\"datasets/test_data.json\",\n ):\n train_data = pd.read_json(train_data_file)\n test_data = pd.read_json(test_data_file)\n return train_data, test_data",
"def train(self)... | [
"0.6166976",
"0.60436237",
"0.59472346",
"0.59368724",
"0.5928723",
"0.59101176",
"0.5907316",
"0.58968824",
"0.58936644",
"0.5892785",
"0.5844393",
"0.5816411",
"0.5815247",
"0.5812829",
"0.5800985",
"0.57745534",
"0.5773249",
"0.575504",
"0.57530016",
"0.5745181",
"0.573280... | 0.64171195 | 0 |
Get an existing UserGpgKey resource's state with the given name, id, and optional extra properties used to qualify the lookup. | def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None,
created_at: Optional[pulumi.Input[str]] = None,
key: Optional[pulumi.Input[str]] = None,
key_id: Optional[pulumi.Input[int]] = None,
user_id: Optional... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_state_by_id(state_id):\n for key, value in storage.all(\"State\").items():\n if state_id == value.id:\n return jsonify(value.to_dict())\n abort(404)",
"def get_state_by_id(state_id):\n my_state = storage.get('State', state_id)\n if my_state is None:\n abort(404)\n ... | [
"0.5549637",
"0.55430037",
"0.5496678",
"0.543263",
"0.5378798",
"0.53005373",
"0.5287543",
"0.5244176",
"0.51912683",
"0.51762015",
"0.51510936",
"0.5111083",
"0.51086766",
"0.5092615",
"0.50612205",
"0.5041373",
"0.50369424",
"0.5009481",
"0.50084484",
"0.49910453",
"0.4983... | 0.7061528 | 0 |
The ID of the GPG key. | def key_id(self) -> pulumi.Output[int]:
return pulumi.get(self, "key_id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def key_id(self):\n return self._key_id",
"def crypto_key_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"crypto_key_id\")",
"def key(self):\n return str(self._id)",
"def get_pgp_key_id(raw_key: bytes) -> str:\n # Flush stdout and stderr to prevent interleaving messages fr... | [
"0.76533425",
"0.73216677",
"0.7293038",
"0.72849256",
"0.7156193",
"0.71369255",
"0.7129503",
"0.7083336",
"0.70065194",
"0.6963701",
"0.69266695",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049",
"0.6895049... | 0.7478572 | 1 |
Create python configuration file for the projection script | def createCfg_project(self, jobOptions):
last_line = '%s %s %s %s' % (jobOptions['projection_module'], self.era, jobOptions['histName'], jobOptions['outputFile'])
if self.projection_module != 'puHist':
last_line += ' %.6e' % jobOptions['ref_genWeight']
lines = jobOptions['inputFiles'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_configuration(self, context):\n context.cfg_path = path = os.path.join(context.env_dir, 'pyvenv.cfg')\n with open(path, 'w', encoding='utf-8') as f:\n f.write('home = %s\\n' % context.python_dir)\n if self.system_site_packages:\n incl = 'true'\n ... | [
"0.66401374",
"0.66170925",
"0.66152537",
"0.65990126",
"0.656565",
"0.656565",
"0.64811194",
"0.64493716",
"0.64300835",
"0.6417359",
"0.64147276",
"0.6409965",
"0.6381156",
"0.63435024",
"0.6338197",
"0.6330227",
"0.62982994",
"0.6296114",
"0.6284715",
"0.62806594",
"0.6273... | 0.67666286 | 0 |
Controller is allow user to change their password if they have valid username and password. It will generate the new password hash and write into the database. If username not exist, or wrong password, controller will not allow user change password. | def change_my_password():
form = ChangePassword()
if request.method == 'GET':
return render_template('changemypassword.html', form=form)
if request.method == 'POST' and form.validate_on_submit():
username = form.username.data
old_password = form.password.data
new_password_has... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def changepassword():\n if request.method == \"POST\":\n\n # Ensure password was submitted\n if not request.form.get(\"newpassword\"):\n return apology(\"must provide password\", 400)\n # Ensure passwords match\n elif request.form.get(\"newpassword\") != request.form.get(\... | [
"0.7494749",
"0.74338984",
"0.7425156",
"0.739893",
"0.73911446",
"0.73620486",
"0.73605317",
"0.73569167",
"0.7258721",
"0.72027224",
"0.71904075",
"0.71764475",
"0.7162846",
"0.71621287",
"0.7122842",
"0.71223277",
"0.70606965",
"0.70595974",
"0.70385784",
"0.70318645",
"0.... | 0.74420726 | 1 |
Controller that display the reset_password page. Only user_email is needed to be input. Controller will validate the email in database and generate a new password 10lenghtrandom string. Then it will try to send a email with new password to user's mailbox by gmail. Email template is email.txt | def reset_password():
form = ResetPassword()
if form.validate_on_submit():
user_email = form.email.data
mail_exist = db.check_email(user_email)
if mail_exist is not None:
new_password = generate_password()
new_password_hash = generate_password_hash(new_password)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def password_reset(request):\n\n\tcontext_dict = {}\n\tif request.method == 'POST':\n\t\temail = request.POST.get('email')\n\t\tif email:\n\t\t\tuser = models.Teacher.objects.get(\n\t\t\t\tsoft_delete=False, user__email=email\n\t\t\t)\n\t\t\tif not user:\n\t\t\t\tcontext_dict[\"message\"] = \"Email ID does'nt exis... | [
"0.78898954",
"0.7747274",
"0.76886064",
"0.7638217",
"0.7600962",
"0.7510319",
"0.7439754",
"0.7414105",
"0.7399373",
"0.7390694",
"0.73104703",
"0.7239809",
"0.72272164",
"0.71323067",
"0.7128626",
"0.7115529",
"0.7113557",
"0.70996207",
"0.70738316",
"0.70691335",
"0.70593... | 0.7804686 | 1 |
Background Cloud Function to be triggered by Cloud Storage. This generic function logs relevant data when a file is changed. | def hello_gcs_generic(data, context):
print('Event ID: {}'.format(context.event_id))
print('Event type: {}'.format(context.event_type))
print('Bucket: {}'.format(data['bucket']))
print('File: {}'.format(data['name']))
print('Metageneration: {}'.format(data['metageneration']))
print('Created: {... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dataprep_job_gcs_trigger(event, context):\n\n head_tail = os.path.split(event['name'])\n newfilename = head_tail[1]\n newfilepath = head_tail[0]\n\n datataprep_auth_token = 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbklkIjoiNDZiOWY2YWUtYTg0Zi00ZWQyLTgxNTMtZDA0MjBjNzIyZTk2IiwiaWF0IjoxNjA2MjI1NTU4... | [
"0.60732645",
"0.5688646",
"0.5619583",
"0.551703",
"0.53179324",
"0.52507126",
"0.52309644",
"0.5212064",
"0.5203661",
"0.51629466",
"0.5137545",
"0.506098",
"0.505003",
"0.5038273",
"0.50262076",
"0.5013108",
"0.497659",
"0.49158835",
"0.4913968",
"0.487022",
"0.485576",
... | 0.64327574 | 0 |
Test the get_factor_list function and factors generator on a few numbers. | def main():
print("-----------------\n|")
print("| codedrome.com |")
print("| Factorization |")
print("-----------------\n")
numbers_to_factorize = [15,19,25,50,77,99]
print("factorization.get_factor_list\n-----------------------------")
for n in numbers_to_factorize:
factors = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_factors():",
"def primeFactors(number):\n factorlist=[]\n loop=2\n while loop<=number:\n if number%loop==0:\n number/=loop\n factorlist.append(loop)\n else: \n loop+=1\n return factorlist",
"def factor(checknumber):\n if checknumber ... | [
"0.703959",
"0.6972541",
"0.68969446",
"0.6865352",
"0.6846568",
"0.6835772",
"0.679891",
"0.67738396",
"0.67580175",
"0.6727128",
"0.6691032",
"0.6637499",
"0.6631842",
"0.6576136",
"0.6561167",
"0.65292734",
"0.6512977",
"0.6510949",
"0.6502786",
"0.64898217",
"0.6483006",
... | 0.7025335 | 1 |
Test that we fallback to gecos if there is no displayname | def test_user_no_displayname(dummy_user_dict):
del dummy_user_dict["displayname"]
dummy_user_dict["gecos"] = ["GCOS"]
user = User(dummy_user_dict)
assert user.name == "GCOS" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_user_no_displayname_no_gcos(dummy_user_dict):\n del dummy_user_dict[\"displayname\"]\n del dummy_user_dict[\"gecos\"]\n dummy_user_dict[\"cn\"] = [\"CN\"]\n user = User(dummy_user_dict)\n assert user.name == \"CN\"",
"def test_user_no_displayname_no_gcos_no_cn(dummy_user_dict):\n del d... | [
"0.60861444",
"0.59474826",
"0.5857862",
"0.57941484",
"0.568906",
"0.5602406",
"0.5574571",
"0.5562333",
"0.55328804",
"0.5530129",
"0.5523503",
"0.5471552",
"0.5394567",
"0.5376542",
"0.5328532",
"0.5319873",
"0.5316677",
"0.53014374",
"0.52880996",
"0.5282158",
"0.5272012"... | 0.6004263 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.