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 |
|---|---|---|---|---|---|---|
test method for create global system config service objects | def test_create_global_system_configs(self):
with self.override_role():
self._create_global_system_config() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_system_entire(self):\n pass",
"def create_config(self) -> None:\n pass",
"def create_config(self) -> None:\n pass",
"def setUpConfig(self):\n pass",
"def test_get_system(self):\n pass",
"def __init__(self):\n '''Lets find ot the system we run ... | [
"0.67117894",
"0.669902",
"0.669902",
"0.66871446",
"0.6668253",
"0.6655135",
"0.6627163",
"0.6558802",
"0.654008",
"0.64688975",
"0.64524055",
"0.6437014",
"0.64075536",
"0.63904804",
"0.63480973",
"0.6305713",
"0.6305713",
"0.62998843",
"0.6291727",
"0.6270461",
"0.62658",
... | 0.74758565 | 0 |
test method for update global system config service objects | def test_update_global_system_config(self):
new_config = self._create_global_system_config()
update_name = data_utils.rand_name('test')
with self.override_role():
self.config_client.update_global_system_config(
new_config['uuid'],
display_name=update_n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_system(self):\n pass",
"def test_update_reg_ex_config(self):\n pass",
"def test_update_software_configuration_for_system_module(self):\n pass",
"def test_ipam_services_update(self):\n pass",
"def test_update_global_config(self):\n result = self.local_gae.query... | [
"0.75745815",
"0.7296947",
"0.72736514",
"0.7099091",
"0.6884556",
"0.68143964",
"0.66094637",
"0.658168",
"0.65406626",
"0.6497593",
"0.64681005",
"0.643284",
"0.63587785",
"0.6349791",
"0.6344749",
"0.63262814",
"0.6315969",
"0.6315969",
"0.6315969",
"0.62961435",
"0.627447... | 0.7454805 | 1 |
test method for delete global system config service objects | def test_delete_global_system_config(self):
new_config = self._create_global_system_config()
with self.override_role():
self.config_client.delete_global_system_config(new_config['uuid']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_ipam_services_delete(self):\n pass",
"def test_delete_hyperflex_sys_config_policy(self):\n pass",
"def test_delete_namespaced_deployment_config(self):\n pass",
"def test_delete_namespaced_build_config(self):\n pass",
"def tearDown(self):\n test_utils.delete_test_... | [
"0.7199809",
"0.7089512",
"0.7032081",
"0.69922334",
"0.69576204",
"0.6904479",
"0.68974847",
"0.684831",
"0.6819755",
"0.662143",
"0.6605294",
"0.6605294",
"0.66023314",
"0.6571069",
"0.6560798",
"0.6553273",
"0.6466658",
"0.6459688",
"0.6441004",
"0.6425311",
"0.6407294",
... | 0.78541297 | 0 |
Return the resource link id as default for its title. | def resource_link_title(self):
return self.request.POST.get("resource_link_title", self.resource_link_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_resource_link_id(self):\r\n return unicode(urllib.quote(\"{}-{}\".format(self.system.hostname, self.location.html_id())))",
"def get_id(self, resource):\n try:\n return resource.href.split('/')[-1]\n except AttributeError:\n return resource['href'].split('/')[-1... | [
"0.69324815",
"0.6888731",
"0.68269897",
"0.64986813",
"0.64661527",
"0.6460758",
"0.6373583",
"0.6373583",
"0.6321089",
"0.6321089",
"0.6321089",
"0.62899864",
"0.6211497",
"0.62084526",
"0.6207754",
"0.6172249",
"0.6172249",
"0.6172249",
"0.6172249",
"0.6172249",
"0.6172249... | 0.72558373 | 0 |
Return the context id as default for its title. | def context_title(self):
return self.request.POST.get("context_title", self.context_id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def title_or_id(context):\n title = getattr(context, 'title', '')\n if not title:\n if hasattr(context, '__name__'):\n title = getattr(context, '__name__', '')\n elif hasattr(context, 'getId'):\n title = context.getId()\n return title",
"def context_id(self) -> str | ... | [
"0.7931017",
"0.64564085",
"0.64163995",
"0.63672",
"0.6259476",
"0.62001634",
"0.61754966",
"0.6164793",
"0.61391497",
"0.613491",
"0.61306226",
"0.605057",
"0.604655",
"0.6037202",
"0.6026433",
"0.5966853",
"0.59568346",
"0.5924754",
"0.59155977",
"0.58879495",
"0.5843314",... | 0.7203953 | 1 |
Get consumer site name from the LTI launch request. Returns string Consumer site name from the request POST parameters | def consumer_site_name(self):
# get the consumer sitename from the lti request
try:
return self.request.POST["tool_consumer_instance_guid"]
except MultiValueDictKeyError:
# in the case of OpenEDX, resource_link_id format is defined in settings.py file.
# it is... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gettoolname(request):\n uri = ''\n if request.uri:\n uri = request.uri\n else:\n uri = request.url\n return urllib.parse.urlparse(uri).path.split('/')[1]",
"def getSiteName():\n return os.environ['SITENAME']",
"def getMachineNameFromRequest(request):\n path = request.path\n\... | [
"0.5987326",
"0.57846445",
"0.577874",
"0.55133516",
"0.5464323",
"0.5415274",
"0.5410879",
"0.5392658",
"0.53773916",
"0.5339937",
"0.5315701",
"0.5290504",
"0.528473",
"0.5272459",
"0.5272459",
"0.52444905",
"0.5235495",
"0.5235495",
"0.5235495",
"0.5235495",
"0.52350014",
... | 0.7727741 | 0 |
Check if the user of the launch request is an instructor on the course. Returns boolean True if the user is an instructor, False otherwise | def is_instructor(self):
return bool(LTI_ROLES[INSTRUCTOR] & self.roles) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_instructor(self):\n # pylint: disable=no-member\n return self.xmodule_runtime.get_user_role() == 'instructor'",
"def has_instructor(self, user, allow_superusers=True):\n return (user.is_superuser and allow_superusers) or len(self.instructors.filter(id=user.id)) > 0",
"def user_auth_... | [
"0.81386656",
"0.7532793",
"0.73093224",
"0.69978017",
"0.698345",
"0.6836744",
"0.6783884",
"0.67611086",
"0.6630022",
"0.6324745",
"0.6300194",
"0.6232442",
"0.6199148",
"0.6169614",
"0.61318046",
"0.6109507",
"0.6062059",
"0.5979534",
"0.59766513",
"0.594827",
"0.59482694"... | 0.75558037 | 1 |
Check if the user of the launch request is a student on the course. Returns boolean True if the user is a student, False otherwise | def is_student(self):
return bool(LTI_ROLES[STUDENT] & self.roles) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_is_student(userobj):\n from .assignment_group import AssignmentGroup\n return AssignmentGroup.published_where_is_candidate(userobj).exists()",
"def is_student_employee():\n return _is_member('uw_affiliation_student-employee')",
"def is_seattle_student():\n return _is_member('uw_affiliation... | [
"0.81439626",
"0.7365152",
"0.73559976",
"0.7234935",
"0.6677735",
"0.6608978",
"0.6584017",
"0.646081",
"0.6395211",
"0.63879806",
"0.6335773",
"0.6327937",
"0.62906736",
"0.6276635",
"0.62218714",
"0.6185517",
"0.61662185",
"0.61015475",
"0.6074799",
"0.6014132",
"0.5993172... | 0.7646404 | 1 |
Get or create the video targetted by the LTI launch request. Create the playlist if it does not preexist (it can only happen with consumer site scope passports). Returns core.models.video.Video The video instance targetted by the `resource_link_id` or None. | def get_or_create_video(self):
# Make sure LTI verification have run successfully
assert getattr(self, "_is_verified", False) or self.verify()
# If the video already exist, retrieve it from database
try:
return Video.objects.get(
lti_id=self.resource_link_id,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_video(self, node):\r\n video = Video()\r\n video.embed_code = self.get_embed_code(node)\r\n video.embed_type = self.get_embed_type(node)\r\n video.width = self.get_width(node)\r\n video.height = self.get_height(node)\r\n video.src = self.get_src(node)\r\n vi... | [
"0.5693211",
"0.5600944",
"0.55802214",
"0.55084",
"0.5409407",
"0.53344846",
"0.5296647",
"0.5253671",
"0.5245499",
"0.52425474",
"0.5238066",
"0.5161256",
"0.5144763",
"0.51414907",
"0.5114479",
"0.5111686",
"0.5095367",
"0.50950116",
"0.50758857",
"0.50685847",
"0.5065476"... | 0.82034284 | 0 |
Returns a function that can be used to apply L1 regularization to weights. L1 regularization encourages sparsity. | def l1_regularizer(scale):
if isinstance(scale, numbers.Integral):
raise ValueError('scale cannot be an integer: %s' % scale)
if isinstance(scale, numbers.Real):
if scale < 0.:
raise ValueError('Setting a scale less than 0 on a regularizer: %g' %
scale)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l1(weights, name=None):\n with ops.op_scope([weights], name, 'l1_regularizer') as scope:\n my_scale = ops.convert_to_tensor(scale,\n dtype=weights.dtype.base_dtype,\n name='scale')\n return stan... | [
"0.74126804",
"0.7267301",
"0.6835751",
"0.6661717",
"0.65519375",
"0.6446731",
"0.6441681",
"0.6424192",
"0.63857955",
"0.637623",
"0.6370715",
"0.6340579",
"0.6312703",
"0.6312528",
"0.6237873",
"0.6226999",
"0.6218044",
"0.6198437",
"0.6190043",
"0.6153269",
"0.6144334",
... | 0.7660338 | 0 |
Applies L1 regularization to weights. | def l1(weights, name=None):
with ops.op_scope([weights], name, 'l1_regularizer') as scope:
my_scale = ops.convert_to_tensor(scale,
dtype=weights.dtype.base_dtype,
name='scale')
return standard_ops.m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l1_regularizer(scale):\n if isinstance(scale, numbers.Integral):\n raise ValueError('scale cannot be an integer: %s' % scale)\n if isinstance(scale, numbers.Real):\n if scale < 0.:\n raise ValueError('Setting a scale less than 0 on a regularizer: %g' %\n ... | [
"0.76275057",
"0.7519611",
"0.6849764",
"0.6681026",
"0.65731126",
"0.6472699",
"0.64654547",
"0.6397305",
"0.6329578",
"0.62666965",
"0.6251209",
"0.6179847",
"0.6166576",
"0.6149099",
"0.6146163",
"0.61426073",
"0.6139323",
"0.6125517",
"0.60945666",
"0.6091269",
"0.6090921... | 0.7763922 | 0 |
Returns a function that can be used to apply L2 regularization to weights. Small values of L2 can help prevent overfitting the training data. | def l2_regularizer(scale):
if isinstance(scale, numbers.Integral):
raise ValueError('scale cannot be an integer: %s' % (scale,))
if isinstance(scale, numbers.Real):
if scale < 0.:
raise ValueError('Setting a scale less than 0 on a regularizer: %g.' %
scal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l2_regularization_penalty(self):\n return self.l2 * (np.linalg.norm(self.weights)**2)",
"def l2_regularization(cg, rate=0.01):\n W = VariableFilter(roles=[WEIGHT])(cg.variables)\n L2_cost = rate * l2_norm(W)\n\n return L2_cost",
"def l2(weights, name=None):\n with ops.op_scope([weigh... | [
"0.80925715",
"0.7583559",
"0.7576561",
"0.74582547",
"0.73601186",
"0.7323454",
"0.7208186",
"0.72009575",
"0.7194931",
"0.7173504",
"0.7140067",
"0.7136975",
"0.69583756",
"0.68992376",
"0.6839116",
"0.6785489",
"0.66890734",
"0.66434085",
"0.6614264",
"0.65683496",
"0.6568... | 0.77493834 | 1 |
Applies l2 regularization to weights. | def l2(weights, name=None):
with ops.op_scope([weights], name, 'l2_regularizer') as scope:
my_scale = ops.convert_to_tensor(scale,
dtype=weights.dtype.base_dtype,
name='scale')
return standard_ops.m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def l2_regularization_penalty(self):\n return self.l2 * (np.linalg.norm(self.weights)**2)",
"def l2_regularization(cg, rate=0.01):\n W = VariableFilter(roles=[WEIGHT])(cg.variables)\n L2_cost = rate * l2_norm(W)\n\n return L2_cost",
"def l2_regularizer(scale):\n if isinstance(scale, numbers.... | [
"0.8091014",
"0.7448874",
"0.73478395",
"0.7267506",
"0.724168",
"0.7128223",
"0.70538986",
"0.6938164",
"0.69292694",
"0.68670356",
"0.68274635",
"0.68120927",
"0.6653745",
"0.6492679",
"0.647313",
"0.64531857",
"0.64282864",
"0.6411279",
"0.63200337",
"0.6207121",
"0.620528... | 0.775654 | 1 |
Test that endpoint returns 200 to successfully get an existing issue | def test_get_existing_issue_passes(self):
response = self.client.get(self.url)
response_json = response.get_json()
self.assertEqual(response.status_code, 200)
self.assertEqual(response_json["name"], TEST_ISSUE_NAME) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_non_existent_issue_fails(self):\n response = self.client.get(self.non_existent_url)\n response_json = response.get_json()\n error_details = response_json[\"error\"]\n self.assertEqual(response.status_code, 404)\n self.assertEqual(error_details[\"message\"], ISSUE_NOT... | [
"0.75867414",
"0.73902005",
"0.73643064",
"0.73238534",
"0.72854304",
"0.72854304",
"0.72405005",
"0.7184897",
"0.7139815",
"0.7139815",
"0.70511526",
"0.70130855",
"0.69772947",
"0.6941858",
"0.6915399",
"0.69113547",
"0.6906659",
"0.68878627",
"0.68749183",
"0.6872209",
"0.... | 0.832497 | 0 |
Test that endpoint returns 401 to update an issue by an unauthenticated user | def test_update_issue_by_unauthenticated_user_fails(self):
response = self.client.patch(
self.url,
json={"description": TEST_ISSUE_DESCRIPTION, "name": TEST_ISSUE_NAME},
)
response_json = response.get_json()
self.assertEqual(response.status_code, 401)
self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unauthenticated_request(self):\n url = self.get_url(self.active_user.id)\n response = self.client.get(url)\n\n expected_status_code = 401\n self.assertEqual(response.status_code, expected_status_code)",
"def test_create_issue_by_unauthenticated_user_fails(self):\n resp... | [
"0.7516022",
"0.7390298",
"0.7305012",
"0.7240846",
"0.72042036",
"0.71837735",
"0.71655804",
"0.7158354",
"0.71411246",
"0.71174425",
"0.7115708",
"0.7115267",
"0.71067286",
"0.71047646",
"0.71047646",
"0.70501995",
"0.7048268",
"0.70121765",
"0.69896954",
"0.6960274",
"0.69... | 0.8461089 | 0 |
Test that endpoint returns 400 to update an issue with an invalid request | def test_update_issue_with_invalid_request_data_fails(self):
response = self.client.patch(
self.url,
headers={"Authorization": self.test_user_token},
json={"issue_description": TEST_ISSUE_DESCRIPTION, "issue_name": ""},
)
response_json = response.get_json()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bad_requests_give_400(self):\n self.assertEqual(self._request({}), 400)",
"def bad_request():\n return HttpError(400)",
"def test_update_issue_with_invalid_request_data_fails(self):\n response = self.client.post(\n self.url,\n headers={\"Authorization\": self.tes... | [
"0.77987164",
"0.76850784",
"0.7648718",
"0.7367075",
"0.73580146",
"0.7346528",
"0.729571",
"0.7294784",
"0.7268057",
"0.725128",
"0.72369045",
"0.7213078",
"0.717171",
"0.70821875",
"0.7068439",
"0.7041047",
"0.7026098",
"0.70238805",
"0.7023123",
"0.7019675",
"0.69905686",... | 0.77710116 | 1 |
Test that endpoint returns 404 to update a non existent issue | def test_update_non_existent_issue_fails(self):
response = self.client.patch(
self.non_existent_url,
headers={"Authorization": self.test_user_token},
json={"description": TEST_ISSUE_DESCRIPTION, "name": TEST_ISSUE_NAME},
)
response_json = response.get_json()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testNotFound(self):\n data = {'text': 'toto'}\n response = requests.put(url=self.invalid_url, json=data)\n headers = response.headers\n json_data = response.json()\n\n self.assertEqual(response.status_code, 404, WRONG_STATUS_CODE_MSG)\n self.assertEqual(\n h... | [
"0.75109035",
"0.74866414",
"0.74578464",
"0.7419704",
"0.73854923",
"0.73162496",
"0.727284",
"0.7267581",
"0.7203608",
"0.71740806",
"0.7172531",
"0.7153326",
"0.714389",
"0.7107214",
"0.7075401",
"0.7074183",
"0.70677465",
"0.7053139",
"0.7043897",
"0.703817",
"0.7036448",... | 0.8417235 | 0 |
Test that endpoint returns 401 to delete an issue by an unauthenticated user | def test_delete_issue_by_unauthenticated_user_fails(self):
response = self.client.delete(
self.url,
)
response_json = response.get_json()
self.assertEqual(response.status_code, 401)
self.assertEqual(response_json["SubCode"], "InvalidToken") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_users_unauthenticated(client: FlaskClient) -> None:\n # Unauthenticated users are not allowed to make the request\n response = delete_users(client)\n assert_error_response(response, HTTPStatus.UNAUTHORIZED)",
"def test_delete_unauthenticated(self):\n\n url = reverse('file')\n\n ... | [
"0.7733872",
"0.77042085",
"0.7531653",
"0.7487137",
"0.74677473",
"0.7453291",
"0.73845005",
"0.7363246",
"0.7293821",
"0.72863674",
"0.724811",
"0.72416186",
"0.72339964",
"0.71999305",
"0.7198206",
"0.7182199",
"0.7163438",
"0.715405",
"0.7144855",
"0.7144765",
"0.7142823"... | 0.86269015 | 0 |
Test that endpoint returns 404 to delete a nonexistent issue | def test_delete_non_existent_issue_fails(self):
response = self.client.delete(
self.non_existent_url, headers={"Authorization": self.test_user_token}
)
response_json = response.get_json()
error_details = response_json["error"]
self.assertEqual(response.status_code, 40... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_not_found(self):\n resp = self.client.delete(\n \"/tracking?repo=not_found1&branch=not_found1\", content_type=\"application/json\", headers=self.auth\n )\n resp_dict = json.loads(resp.data)\n self.assertIn(\"code\", resp_dict, msg=\"Error in data format return... | [
"0.7706101",
"0.7693295",
"0.74782056",
"0.74614143",
"0.74124074",
"0.7393357",
"0.7392625",
"0.73672146",
"0.7346239",
"0.73245335",
"0.73038",
"0.7288201",
"0.7203828",
"0.7168691",
"0.7166301",
"0.7163927",
"0.7158053",
"0.7135521",
"0.71196383",
"0.71181154",
"0.7103441"... | 0.8426744 | 0 |
Test that endpoint returns 401 to create a new issue by an unauthenticated user | def test_create_issue_by_unauthenticated_user_fails(self):
response = self.client.post(
self.url,
json={"description": TEST_ISSUE_DESCRIPTION, "name": TEST_ISSUE_NAME},
)
response_json = response.get_json()
self.assertEqual(response.status_code, 401)
self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unauthorized_create_user(self):\n res = self.submit()\n\n assert res.status_code == 401",
"def test_update_issue_by_unauthenticated_user_fails(self):\n response = self.client.patch(\n self.url,\n json={\"description\": TEST_ISSUE_DESCRIPTION, \"name\": TEST_ISS... | [
"0.7725986",
"0.7681252",
"0.7239422",
"0.71773916",
"0.71711415",
"0.71470416",
"0.71207446",
"0.71150017",
"0.70923895",
"0.70384675",
"0.7037222",
"0.7032824",
"0.70011616",
"0.7000968",
"0.69924366",
"0.69902384",
"0.69893515",
"0.6978107",
"0.69578373",
"0.69578373",
"0.... | 0.8437491 | 0 |
True if the object is a true instruction (not a label or comment). | def is_instruction(self):
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_instruction(self):\n return True",
"def bool(self, obj):\n return True",
"def bool(self, obj):\n return True",
"def __bool__(self):\n return bool(self.obj)",
"def __bool__(self):\n return self is TRUE",
"def __nonzero__(self):\r\n return bool(assert_(self.... | [
"0.76811403",
"0.7117996",
"0.7117996",
"0.68840647",
"0.6872917",
"0.6738199",
"0.6497041",
"0.63739187",
"0.6369928",
"0.6329838",
"0.6326438",
"0.6312929",
"0.62702847",
"0.62645316",
"0.62295204",
"0.62030894",
"0.62030894",
"0.61995995",
"0.6184086",
"0.6169522",
"0.6160... | 0.75115293 | 1 |
True if the object is a true instruction (not a label or comment). | def is_instruction(self):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_instruction(self):\n return False",
"def bool(self, obj):\n return True",
"def bool(self, obj):\n return True",
"def __bool__(self):\n return bool(self.obj)",
"def __bool__(self):\n return self is TRUE",
"def __nonzero__(self):\r\n return bool(assert_(self... | [
"0.75115293",
"0.7117996",
"0.7117996",
"0.68840647",
"0.6872917",
"0.6738199",
"0.6497041",
"0.63739187",
"0.6369928",
"0.6329838",
"0.6326438",
"0.6312929",
"0.62702847",
"0.62645316",
"0.62295204",
"0.62030894",
"0.62030894",
"0.61995995",
"0.6184086",
"0.6169522",
"0.6160... | 0.76811403 | 0 |
Returns ELO scores for all teams at specified date in a pandas.DataFrame. If no date is specified, get today's scores | def read_by_date(self, date=None):
if not date:
date = datetime.today()
elif isinstance(date, str):
date = datetime.strptime(date, "%Y-%m-%d")
else:
pass # Assume datetime object
datestring = date.strftime("%Y-%m-%d")
filepath = Path(datadir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_games(date):\n scoreboard = nba_py.Scoreboard(month=date.month,\n day=date.day,\n year=date.year)\n line_score = scoreboard.line_score()\n game_header = scoreboard.game_header()\n\n games = []\n current_game = {}\n game_s... | [
"0.6339818",
"0.58361536",
"0.57906604",
"0.57695806",
"0.5495597",
"0.5477347",
"0.5441314",
"0.53961635",
"0.5378694",
"0.53744346",
"0.53138196",
"0.5309152",
"0.53008497",
"0.52496976",
"0.5241952",
"0.52405655",
"0.52084786",
"0.5184438",
"0.5166165",
"0.5163643",
"0.516... | 0.636757 | 0 |
Downloads full ELO history for one team Returns pandas.DataFrame | def read_team_history(self, team, max_age=1):
if isinstance(max_age, int):
_max_age = timedelta(days=max_age)
elif isinstance(max_age, timedelta):
_max_age = max_age
else:
raise TypeError('max_age must be of type int or datetime.timedelta')
teams_to_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_leaderboard(competition: str) -> pd.DataFrame:\n api = kaggle_api()\n with tempfile.TemporaryDirectory() as tmpdir, remember_cwd(tmpdir):\n log.info(\"Downloading leaderboard\")\n api.competition_leaderboard_download(competition, tmpdir)\n zf = glob.glob('*.zip')[0]\n df ... | [
"0.60985726",
"0.6020712",
"0.5985176",
"0.5956116",
"0.5896116",
"0.5866729",
"0.5857276",
"0.5827826",
"0.5715959",
"0.5691035",
"0.56865895",
"0.56862915",
"0.5672612",
"0.56625384",
"0.5655198",
"0.56416035",
"0.5636655",
"0.56260455",
"0.5580652",
"0.556989",
"0.5560936"... | 0.64927334 | 0 |
Converts a tree to a linkage matrix | def convert_tree_to_mat(tree):
mat = []
sizes = {}
index = len(tree) + 1
for i, node in enumerate(tree):
size = 0
if node.left < 0:
left = abs(node.left) + len(tree)
size += sizes[left]
else:
left = node.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_linkage_matrix(clustering: AgglomerativeClustering) -> np.ndarray:\n # Create the counts of samples under each node\n counts = np.zeros(clustering.children_.shape[0])\n n_samples = len(clustering.labels_)\n for i, merge in enumerate(clustering.children_):\n current_count = 0\n ... | [
"0.6236304",
"0.5905784",
"0.570178",
"0.5700652",
"0.5679518",
"0.5610885",
"0.5609696",
"0.55756336",
"0.55395305",
"0.55023617",
"0.54923624",
"0.54468626",
"0.53921676",
"0.53777665",
"0.53343254",
"0.53247654",
"0.5289881",
"0.52824944",
"0.5268672",
"0.52499205",
"0.523... | 0.6934348 | 0 |
adds to the list of groupings where this cluster was generated | def add_clusterings(self, clustering):
self.clustering.append(clustering) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_groups(self):\n for g in self.groups:\n self.add_group(groupname=g['groupname'],\n grouptitle=g['grouptitle'],\n path_to_group=g['path'])",
"def addToGroups(self, *groups):\n for g in groups:\n g.add(self)",
"def a... | [
"0.6263413",
"0.61576265",
"0.6112672",
"0.6103986",
"0.60334396",
"0.60252625",
"0.60209674",
"0.5992753",
"0.5991146",
"0.59870017",
"0.59856635",
"0.593876",
"0.59186405",
"0.5908947",
"0.5879168",
"0.5855146",
"0.5815371",
"0.57854056",
"0.5783416",
"0.5767001",
"0.573325... | 0.7037796 | 0 |
Returns a string with the most important stats of a cluster | def get_stats(self):
stats = \
'cluster: %s\ncount = %d, size = %d, minvar = %f, avg_dist = %s\n'\
% (self.name, self.count, self.size, self.minvar, self.avg_dist)
return stats | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_overview(self) -> None:\n print(f\"\\n\\nCluster overview:\")\n all_clusters = self.get_all_clusters()\n print(f\" - Total of {len(all_clusters)} clusters\")\n if all_clusters:\n cluster_lengths = [len(v) for v in all_clusters.values()]\n print(f\" - Avera... | [
"0.67956924",
"0.67628664",
"0.64958215",
"0.64666176",
"0.6381101",
"0.63753426",
"0.63383025",
"0.6319494",
"0.630857",
"0.6304111",
"0.6215359",
"0.6209854",
"0.6204789",
"0.61982137",
"0.6185798",
"0.6137368",
"0.6112001",
"0.6091134",
"0.60871667",
"0.607449",
"0.6027842... | 0.73688114 | 0 |
Compares 2 clusters and returns name of smaller cluster if it is similar to the bigger one. 2 clusters are similar if a. the samller cluster is a subset of the bigger cluster b. the 2 clusters are similar in size and their intersection is more than proportion times len of smaller cluster | def are_clusters_similar(cls, c1, c2, proportion=0.8):
if len(c1.indices) > len(c2.indices):
c1_idx = set(c1.indices.tolist())
c2_idx = set(c2.indices.tolist())
smaller = c2.name
else:
c1_idx = set(c2.indices.tolist())
c2_idx = set(c1.indices.t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare(self):\n len0 = len(self.cluster_lists[0])\n len1 = len(self.cluster_lists[1])\n longer_index = 0 if len0 >= len1 else 1\n shorter_index = 1 if len1 <= len0 else 0\n self.stars_length = len(self.cluster_lists[shorter_index]) \n self.starlets_length = len(self.c... | [
"0.7382835",
"0.7021584",
"0.6907499",
"0.67762184",
"0.61626005",
"0.615847",
"0.61380166",
"0.6116766",
"0.61097395",
"0.6108866",
"0.608056",
"0.606497",
"0.60270023",
"0.60196763",
"0.6018278",
"0.5966947",
"0.5951447",
"0.5931103",
"0.59275836",
"0.5896336",
"0.58864814"... | 0.7711708 | 0 |
Computes the average of distances for given set of indices | def get_cluster_average(cls, indices, dist_mat):
distances = cls.get_all_distances(indices, dist_mat)
return np.mean(distances) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def average_qa_distance(distances):\n\treturn np.average(np.median(distances,axis=0))",
"def computeCentroids(myX, myidxs):\n subX = []\n for x in range(len(np.unique(myidxs))):\n subX.append(np.array([myX[i] for i in range(myX.shape[0]) if myidxs[i] == x]))\n return np.array([np.mean(thisX,axis=... | [
"0.63189465",
"0.6313924",
"0.6230694",
"0.62180656",
"0.6207531",
"0.61965734",
"0.6147521",
"0.61238205",
"0.60802734",
"0.60790086",
"0.5996191",
"0.5959901",
"0.5953873",
"0.5884494",
"0.5878181",
"0.5878181",
"0.5876896",
"0.57958776",
"0.5790317",
"0.57663274",
"0.57536... | 0.7050681 | 0 |
Computes the variance of distances for given set of indices | def get_cluster_variance(cls, indices, dist_mat):
distances = cls.get_all_distances(indices, dist_mat)
return np.var(distances) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dissimilarity(clusters):\n totDist = 0\n for c in clusters:\n totDist += c.variability()\n return totDist",
"def evaluate_diversity_single(indices, distances, weight=0.5):\n i, j = [e for e in zip(*itertools.combinations(indices, 2))]\n subset_distances = distances[i, j]\n minimum = ... | [
"0.57715565",
"0.5706007",
"0.5688792",
"0.5670043",
"0.5596368",
"0.55444354",
"0.54851794",
"0.5440689",
"0.5433092",
"0.5379177",
"0.5339256",
"0.5314547",
"0.53114134",
"0.5303679",
"0.52982926",
"0.5282687",
"0.5250375",
"0.5205763",
"0.5200898",
"0.51946765",
"0.5171582... | 0.7187772 | 0 |
Tests generating and verifying a good token. | def test_gen_and_verify_good_token(self):
config.set(xsrf_token_key='abcdef')
tool = utils.XsrfTool()
token = tool.generate_token(12345, 'test_action')
self.assertTrue(tool.verify_token(token, 12345, 'test_action')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_token_generation(self):\n self.assertIsInstance(self.user.generate_auth_token(34), bytes)",
"def test_make_token(self):\n user = self.create_user()\n\n token_generator = EmailActivationTokenGenerator()\n token = token_generator.make_token(user)\n self.assertTrue(token_... | [
"0.8058459",
"0.79768527",
"0.7909693",
"0.77088344",
"0.7664468",
"0.7508158",
"0.7480822",
"0.73563755",
"0.733421",
"0.7329963",
"0.7329963",
"0.7329963",
"0.7317949",
"0.7289738",
"0.7275595",
"0.72160363",
"0.7193532",
"0.71132725",
"0.7094052",
"0.70326144",
"0.7030384"... | 0.8586757 | 0 |
Tests that an invalid token is rejected. | def test_rejects_invalid_tokens(self):
config.set(xsrf_token_key='abcdef')
tool = utils.XsrfTool()
self.assertFalse(tool.verify_token(
'ThisTokenDoesNotEvenHaveASlash', 12345, 'test_action'))
timestamp = utils.get_timestamp(XsrfToolTests.TEST_NOW)
self.assertFalse(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unused_token_is_valid(self):\n assert self.token.is_valid()",
"def testIsValidToken(self):\n self.assertTrue(TokenResource.isValidToken('aValidToken'),\n msg='Expected isValidToken to accept a valid token.')\n self.assertTrue(TokenResource.isValidToken(TokenRe... | [
"0.80833066",
"0.7421202",
"0.7316849",
"0.7283676",
"0.7186531",
"0.7133089",
"0.7120601",
"0.7105396",
"0.7096292",
"0.70445323",
"0.7015455",
"0.6942293",
"0.6895147",
"0.687939",
"0.68620676",
"0.6820967",
"0.68117726",
"0.68035525",
"0.6787949",
"0.67304504",
"0.672594",... | 0.80625 | 1 |
Tests that an expired token is rejected. | def test_rejects_expired_token(self):
config.set(xsrf_token_key='abcdef')
tool = utils.XsrfTool()
token = tool.generate_token(12345, 'test_action')
utils.set_utcnow_for_test(XsrfToolTests.TEST_NOW +
datetime.timedelta(hours=4, minutes=1))
self.as... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_raises_token_expired_when_applicable(self):\n\n badgr = self.get_badgr_setup()\n with vcr.use_cassette('tests/vcr_cassettes/no_valid_auth_token.yaml'):\n with self.assertRaises(exceptions.TokenAndRefreshExpiredError):\n badgr.get_from_server(self._sample_url)",
"d... | [
"0.7818172",
"0.7548095",
"0.7417047",
"0.7357766",
"0.7188758",
"0.7184504",
"0.70577645",
"0.7048784",
"0.7038498",
"0.7019122",
"0.6993201",
"0.69926786",
"0.69330657",
"0.6910855",
"0.68841475",
"0.6876042",
"0.68597424",
"0.68528163",
"0.6845937",
"0.67801154",
"0.675982... | 0.8659471 | 0 |
Tests a good token when a token key has to be autogenerated. If the config doesn't already have an XSRF token key set, the XSRF tool will generate one automatically. | def test_good_with_no_prior_key(self):
# config seems to be shared across tests, so we have to specifically set
# it to None.
config.set(xsrf_token_key=None)
tool = utils.XsrfTool()
token = tool.generate_token(12345, 'test_action')
self.assertTrue(tool.verify_token(token,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_gen_and_verify_good_token(self):\n config.set(xsrf_token_key='abcdef')\n tool = utils.XsrfTool()\n token = tool.generate_token(12345, 'test_action')\n self.assertTrue(tool.verify_token(token, 12345, 'test_action'))",
"def test_bad_with_no_prior_key(self):\n # config se... | [
"0.78918177",
"0.733531",
"0.6408386",
"0.6221698",
"0.621149",
"0.6204559",
"0.61811525",
"0.61677104",
"0.6149253",
"0.6127415",
"0.61166877",
"0.6086365",
"0.60314023",
"0.60068244",
"0.59591615",
"0.595839",
"0.5935682",
"0.5916579",
"0.59162694",
"0.5880758",
"0.58686036... | 0.8223422 | 0 |
Tests a bad token when a token key has to be autogenerated. If the config doesn't already have an XSRF token key set, the XSRF tool will generate one automatically. | def test_bad_with_no_prior_key(self):
# config seems to be shared across tests, so we have to specifically set
# it to None.
config.set(xsrf_token_key=None)
tool = utils.XsrfTool()
timestamp = utils.get_timestamp(XsrfToolTests.TEST_NOW)
self.assertFalse(
tool.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_good_with_no_prior_key(self):\n # config seems to be shared across tests, so we have to specifically set\n # it to None.\n config.set(xsrf_token_key=None)\n tool = utils.XsrfTool()\n token = tool.generate_token(12345, 'test_action')\n self.assertTrue(tool.verify_t... | [
"0.8259772",
"0.76561594",
"0.69411904",
"0.6720464",
"0.6638457",
"0.6632962",
"0.63934356",
"0.6235009",
"0.62175906",
"0.6185756",
"0.61814946",
"0.6169995",
"0.61660737",
"0.61657643",
"0.61594146",
"0.61461985",
"0.6126648",
"0.612142",
"0.60947907",
"0.60913736",
"0.608... | 0.79827213 | 1 |
This PartialTime must be just a day of the week (i.e. "this Friday", "next Friday"), or a day, optionally with a month ("the 2nd [of a month]"). offset is in terms of weeks. | def relative_day_of_week(self, context=None, offset=0):
if self.dayofweek:
offset += 1
context = context or self.__class__.now()
contextdate = context.as_date()
contextdayofweek = contextdate.weekday() + 1
dayofweekdiff = datetime.timedelta(self.dayofw... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def offset(self):\n\n offsetList = ['12 am', '1 am', '2 am', '3 am', '4 am', '5 am', '6 am', '7 am', '8 am', '9 am',\n '10 am', '11 am', '12 pm', '1 pm', '2 pm', '3 pm', '4 pm', '5 pm', '6 pm', '7 pm',\n '8 pm', '9 pm', '10 pm', '11 pm', '12 pm']\n\n firstTim... | [
"0.5157391",
"0.4994248",
"0.49381125",
"0.47396106",
"0.47242022",
"0.471829",
"0.4675295",
"0.46751907",
"0.46456775",
"0.4620699",
"0.46169677",
"0.46139914",
"0.46081308",
"0.4573974",
"0.45564663",
"0.45498174",
"0.45492557",
"0.45436284",
"0.4541632",
"0.4540858",
"0.45... | 0.69523025 | 0 |
obj can be a PartialTime, datetime.datetime, datetime.date, datetime.time, or dictionary. | def from_object(obj):
if isinstance(obj, PartialTime):
return obj
d = {}
for attr in partialtime_attrs:
try:
d[attr] = getattr(obj, attr)
continue
except AttributeError:
pass
try:
d[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize_obj(obj: Any) -> Any:\n if isinstance(obj, (datetime.date, datetime.datetime)):\n return obj.isoformat()\n else:\n return obj",
"def serialize_obj(obj: Any) -> Any:\n if isinstance(obj, (datetime.date, datetime.datetime)):\n return obj.isoformat()\n else:\n r... | [
"0.68085885",
"0.68085885",
"0.65015125",
"0.64940405",
"0.64926344",
"0.6421956",
"0.64154804",
"0.628555",
"0.62833035",
"0.6281725",
"0.6259862",
"0.62515557",
"0.61389625",
"0.611342",
"0.6029079",
"0.6004232",
"0.597295",
"0.59600604",
"0.59587055",
"0.5953708",
"0.59535... | 0.7220175 | 0 |
Return keymapping > actions for human play. | def get_keys_to_action(self) -> dict[tuple[int], ale_py.Action]:
UP = ord("w")
LEFT = ord("a")
RIGHT = ord("d")
DOWN = ord("s")
FIRE = ord(" ")
mapping = {
ale_py.Action.NOOP: (None,),
ale_py.Action.UP: (UP,),
ale_py.Action.FIRE: (FIRE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def action_map(self):\n return self._action_map",
"def action_map(self) -> Dict[str, CLIActionType]:\n return add_dicts({\n \"dump\": self.dump_action,\n \"dump-macrosizes\": self.dump_macrosizes_action,\n \"dump_macrosizes\": self.dump_macrosizes_action,\n ... | [
"0.7114411",
"0.7016313",
"0.6894572",
"0.66823757",
"0.6482857",
"0.6474927",
"0.62834466",
"0.620882",
"0.61970484",
"0.6148902",
"0.6146836",
"0.6096387",
"0.60904884",
"0.60904306",
"0.5945399",
"0.59279794",
"0.59279794",
"0.59279794",
"0.5920543",
"0.5886699",
"0.585949... | 0.71423876 | 0 |
Return the meaning of each integer action. | def get_action_meanings(self) -> list[str]:
keys = ale_py.Action.__members__.values()
values = ale_py.Action.__members__.keys()
mapping = dict(zip(keys, values))
return [mapping[action] for action in self._action_set] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def actions(self, state):\n\n\t\t# Returns the possible numbers we can use.\n\t\treturn [(str)(x + 1) for x in range (0,self.size)]",
"def get_actions(self):\r\n return -4,4",
"def get_human_action(self):\n choice = input(\n \"Ingrese la acción a realizar por el jugador {}: \".format(s... | [
"0.64544517",
"0.61044216",
"0.6041709",
"0.6033038",
"0.5959401",
"0.5918232",
"0.59029806",
"0.5858366",
"0.58277667",
"0.5769874",
"0.5755516",
"0.5755516",
"0.57469946",
"0.57382166",
"0.57157433",
"0.57149076",
"0.5700967",
"0.5682621",
"0.5673893",
"0.56725633",
"0.5618... | 0.6149662 | 1 |
Restore emulator state w/o system state. | def restore_state(self, state: ale_py.ALEState):
self.ale.restoreState(state) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def restore_full_state(self, state):\n state_ref = self.ale.decodeState(state)\n self.ale.restoreSystemState(state_ref)\n self.ale.deleteState(state_ref)",
"def restore_state(self, state):\n state_ref = self.ale.decodeState(state)\n self.ale.restoreState(state_ref)\n sel... | [
"0.7186125",
"0.6867466",
"0.6819699",
"0.65463877",
"0.6529676",
"0.64869994",
"0.64532864",
"0.6447222",
"0.6442397",
"0.64415807",
"0.63747936",
"0.63088065",
"0.63051534",
"0.62964404",
"0.62821954",
"0.6271038",
"0.62552905",
"0.62118226",
"0.6202963",
"0.620052",
"0.619... | 0.7003184 | 1 |
Deprecated method which would clone the emulator and system state. | def clone_full_state(self) -> ale_py.ALEState:
logger.warn(
"`clone_full_state()` is deprecated and will be removed in a future release of `ale-py`. "
"Please use `clone_state(include_rng=True)` which is equivalent to `clone_full_state`. "
)
return self.ale.cloneSystemSta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clone_full_state(self):\n state_ref = self.ale.cloneSystemState()\n state = self.ale.encodeState(state_ref)\n self.ale.deleteState(state_ref)\n return state",
"def clone_state(self):\n state_ref = self.ale.cloneState()\n state = self.ale.encodeState(state_ref)\n ... | [
"0.6363721",
"0.5618662",
"0.55789024",
"0.554215",
"0.55219865",
"0.54947555",
"0.5411485",
"0.5397617",
"0.5383854",
"0.5382225",
"0.5321751",
"0.530764",
"0.5300784",
"0.529221",
"0.51634264",
"0.5160417",
"0.51600796",
"0.51446545",
"0.514345",
"0.508876",
"0.5072999",
... | 0.7202347 | 0 |
Change work directory to path. The path will be created if not existed. | def change_work_directory(self, path):
if not self.check_file(path):
warn_log("Path[%s] not found, try to create", path)
create_path = "mkdir -p " + path + self.echo_cmd_result
self.connector.sendline(create_path)
i = self.connector.expect(['\r\n0\r\n', '\r\n1\r\n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_directory(path):\n os.chdir(path)",
"def change_dir(path): \r\n os.chdir(path)",
"def set_working_dir(path):\n full_path = os.path.abspath(os.path.expanduser(path))\n full_cwd = os.path.abspath(os.getcwd())\n if full_cwd != full_path:\n os.chdir(full_path)\n LOGGER.inf... | [
"0.7421435",
"0.7313681",
"0.71127903",
"0.7029804",
"0.6981648",
"0.6796002",
"0.67470753",
"0.6727051",
"0.6708363",
"0.67031044",
"0.66876256",
"0.6652647",
"0.65244085",
"0.6514107",
"0.650485",
"0.64177454",
"0.64068246",
"0.63959193",
"0.6362679",
"0.63602567",
"0.63470... | 0.7994197 | 0 |
Check the command is existed or not | def check_command(self, cmd):
which = "which " + cmd + self.echo_cmd_result
self.connector.sendline(which)
i = self.connector.expect(['\r\n0\r\n', '\r\n1\r\n', '\r\n2\r\n'])
if i == 0:
debug_log("command[%s] found!", cmd)
return True
else:
warn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_commands(self):\n pass",
"def is_valid_command(args):\n if args.command is not None:\n return True\n return False",
"def run_command_check(self):\n pass",
"def test_importtleCommandExists(self):\n self.assertIn('importtle', get_commands())",
"def check_for(comman... | [
"0.76942766",
"0.74593234",
"0.7369007",
"0.7323209",
"0.7318305",
"0.723259",
"0.71493363",
"0.70913726",
"0.70579386",
"0.70093393",
"0.6972828",
"0.6948893",
"0.69349575",
"0.6879799",
"0.68721604",
"0.68480384",
"0.67979854",
"0.6721152",
"0.6717408",
"0.6705048",
"0.6697... | 0.7612025 | 1 |
Start server by script and check the server | def start_server(self, server, script):
self.connector.sendline(script)
expect = "88.Exit"
i = self.connector.expect([expect, TIMEOUT], timeout=2)
if i == 0:
info_log("Start server[%s] success!",server)
return True
else:
warn_log("Start server[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start():\n\n start_server()",
"def __run_server(self):\n os.chdir(os.path.dirname(self.server_path))\n self.server_process = subprocess.Popen([self.server_path, \\\n \"{}:{}\".format(self.args.ip, self.args.port)])",
"def start_server(self):\n if not self._server:... | [
"0.75750923",
"0.73307216",
"0.72864425",
"0.7149142",
"0.70754975",
"0.7070639",
"0.70293385",
"0.70130366",
"0.70004296",
"0.6991362",
"0.6943074",
"0.69397074",
"0.69325835",
"0.691967",
"0.68687785",
"0.6830284",
"0.68131477",
"0.6801077",
"0.67762166",
"0.6775851",
"0.67... | 0.816128 | 0 |
Salts and hashes a password with the username with SHA256 | def simple_hash(username:str,password: str):
salted_hash = username+password
return str(sha256(salted_hash.encode('utf-8')).hexdigest()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_password(username, password):\n m = hashlib.sha512()\n m.update(username.encode('utf-8'))\n m.update(password.encode('utf-8'))\n return m.hexdigest()",
"def hash_password(password):\n\n return hashlib.sha224(password).hexdigest()[:20]",
"def hashPassword(passwd):\r\n \r\n return... | [
"0.7658351",
"0.7464068",
"0.73898196",
"0.73531955",
"0.73487467",
"0.73217756",
"0.7319004",
"0.72887933",
"0.7268249",
"0.7262144",
"0.72038954",
"0.7174314",
"0.7156075",
"0.71550053",
"0.7139567",
"0.7121662",
"0.706768",
"0.7044234",
"0.7044234",
"0.7044234",
"0.7019703... | 0.81073076 | 0 |
Endpoint for getting a posts , optionally filtering by title and/or body | def posts_get():
title_like = request.args.get("title_like")
body_like = request.args.get("body_like")
posts = session.query(Post)
if title_like:
if body_like:
posts = posts.filter(
Post.title.contains(title_like), Post.body.contains(body_like))
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_posts():\n url = app.config['POSTS_ENDPOINT']\n response = requests.get(url, params={})\n if response.status_code == 200:\n return parse_posts(response.json())\n raise RuntimeError('Error in retrieving posts.')",
"def posts_get():\n \n\n # Get and filter the posts from the databa... | [
"0.69784904",
"0.6897439",
"0.6682452",
"0.64733714",
"0.647116",
"0.64384276",
"0.64301986",
"0.64056396",
"0.63871115",
"0.6280851",
"0.6247125",
"0.62147796",
"0.6195686",
"0.61450994",
"0.6144",
"0.61002445",
"0.60592014",
"0.6029914",
"0.6007665",
"0.596298",
"0.5931895"... | 0.7861696 | 0 |
Endpoint for getting a post with a specifi id | def post_get(id):
post = session.query(Post).get(id)
if not post:
message = "Could not find post with id {}".format(id)
data = json.dumps({"message": message})
return Response(data, 404, mimetype="application/json")
data = json.dumps(post.as_dictionary())
return Response(data, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, id):\t\t\n\t\ttry:\n\t\t\treturn post_service.get(id)\n\t\texcept AssertionError as e:\n\t\t\tpost_space.abort(400, e.args[0], status = \"Could not get post\", statusCode = \"400\")\n\t\texcept Exception as e:\n\t\t\tpost_space.abort(500, e.args[0], status = \"Could not get post\", statusCode = \"500... | [
"0.81270456",
"0.7322102",
"0.71913266",
"0.6945908",
"0.6818256",
"0.6618395",
"0.65972865",
"0.6572902",
"0.6547997",
"0.65261894",
"0.64631104",
"0.6461673",
"0.6457126",
"0.64499605",
"0.64324766",
"0.6422234",
"0.6408761",
"0.6394067",
"0.63926244",
"0.6391496",
"0.63821... | 0.78085524 | 1 |
Endpoint for adding a post | def posts_post():
data = request.json
try:
validate(data, post_schema)
except ValidationError as error:
data = {"message": error.message}
return Response(json.dumps(data), 422, mimetype="application/json")
post = Post(title=data["title"], body=data["body"])
session.add(post... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self, post_id=None):\n\n if post_id:\n abort(400)\n else:\n args = parsers.post_post_parser.parse_args(strict=True)\n\n new_post = Post(args['title'])\n new_post.text = args['text']\n # new_post.user = user\n\n if args['tags']... | [
"0.74371886",
"0.73819596",
"0.7375056",
"0.73609734",
"0.731582",
"0.7287887",
"0.7260553",
"0.7228376",
"0.7113653",
"0.71114963",
"0.71114963",
"0.71015245",
"0.6973861",
"0.6942882",
"0.6938936",
"0.6925478",
"0.6884716",
"0.6880377",
"0.6842007",
"0.6840143",
"0.6795057"... | 0.75065815 | 0 |
Copy variables src_scope to dest_scope | def _get_copy_var_ops(self, dest_scope_name='target', src_scope_name='main'):
op_holder = []
src_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=src_scope_name)
dest_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=dest_scope_name)
for src_var, dest_var... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_src_to_dst(from_scope, to_scope):\n from_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, from_scope)\n to_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, to_scope)\n\n op_holder = []\n for from_var, to_var in zip(from_vars, to_vars):\n op_holder.append(to_var.assig... | [
"0.79303914",
"0.6721718",
"0.665844",
"0.6505322",
"0.6498187",
"0.6306764",
"0.61816907",
"0.61085176",
"0.6105042",
"0.59125614",
"0.59033614",
"0.58532274",
"0.5833769",
"0.58153504",
"0.5750617",
"0.5714156",
"0.5706584",
"0.5702113",
"0.5689121",
"0.56677413",
"0.565025... | 0.71958286 | 1 |
Find whether this host is offline. | def is_offline(self):
return not self.is_online | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_offline(self):\n\n\t\treturn self.__offline",
"def can_detect_offline(self):\n raise NotImplementedError(\"Abstract method, must be overridden\")",
"def is_online(self) -> bool:\n return self.data[Attribute.ONLINE]",
"def am_i_offline(self):\n # -num_of_last_check_rounds_consider... | [
"0.7266479",
"0.7186407",
"0.6736314",
"0.6714472",
"0.6586879",
"0.64810205",
"0.6474933",
"0.64588964",
"0.64490753",
"0.6334723",
"0.6151179",
"0.6090766",
"0.60387033",
"0.60159165",
"0.59867877",
"0.59785944",
"0.5955263",
"0.59521246",
"0.59268737",
"0.5923758",
"0.5923... | 0.8027574 | 0 |
Create a host object from an API response. | def from_response(cls, body, identity):
if not body:
raise ValueError('Cannot construct host from empty response')
try:
root = cElementTree.fromstring('<root>' + body + '</root>')
if root.find('status').text != 'success':
message = root.find('statusm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_response(cls, response):\n\n d = {\n \"headers\": dict(response.getheaders()),\n \"content\": response.read(),\n \"status\": response.status,\n \"reason\": response.reason,\n \"raw_headers\": response.msg.headers,\n \"length\": respo... | [
"0.6119124",
"0.60843724",
"0.6050096",
"0.60058904",
"0.59797037",
"0.582096",
"0.5803768",
"0.5744557",
"0.5744557",
"0.57210386",
"0.5685111",
"0.5648609",
"0.5628594",
"0.56005067",
"0.55563015",
"0.54960114",
"0.54716104",
"0.5431569",
"0.5344858",
"0.52858144",
"0.52783... | 0.8027098 | 0 |
Create operator layer class for a single operator Returns a class that inherits from lbann.OperatorLayer. | def generate_operator_layer(operator_class):
def __init__(self, *args, **kwargs):
"""Operator layer with a single operator
Forwards arguments to lbann.OperatorLayer or sub-class of
lbann.Operator.
"""
layer_kwargs = lbann.Layer.__init__.__kwdefaults__.copy()
op_kwa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n layer_kwargs = lbann.Layer.__init__.__kwdefaults__.copy()\n op_kwargs = {}\n for key, value in kwargs.items():\n if key in layer_kwargs:\n layer_kwargs[key] = value\n else:\n op_kwargs[key] = value\n ... | [
"0.71416163",
"0.6397439",
"0.6372887",
"0.63468915",
"0.6018684",
"0.5997482",
"0.5856959",
"0.57220036",
"0.56762886",
"0.5640218",
"0.5564729",
"0.5532379",
"0.5518034",
"0.55132145",
"0.5483321",
"0.54782385",
"0.54617363",
"0.5436568",
"0.5424891",
"0.542397",
"0.5410954... | 0.76687634 | 0 |
Operator layer with a single operator Forwards arguments to lbann.OperatorLayer or subclass of lbann.Operator. | def __init__(self, *args, **kwargs):
layer_kwargs = lbann.Layer.__init__.__kwdefaults__.copy()
op_kwargs = {}
for key, value in kwargs.items():
if key in layer_kwargs:
layer_kwargs[key] = value
else:
op_kwargs[key] = value
layer_kwa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_operator_layer(operator_class):\n\n def __init__(self, *args, **kwargs):\n \"\"\"Operator layer with a single operator\n\n Forwards arguments to lbann.OperatorLayer or sub-class of\n lbann.Operator.\n\n \"\"\"\n layer_kwargs = lbann.Layer.__init__.__kwdefaults__.c... | [
"0.6675716",
"0.646894",
"0.64264107",
"0.63093054",
"0.6119068",
"0.6038692",
"0.6030926",
"0.5984362",
"0.5972014",
"0.5886634",
"0.58821154",
"0.5828552",
"0.5806812",
"0.5763366",
"0.5760713",
"0.5744891",
"0.5731462",
"0.5729544",
"0.5714012",
"0.56910795",
"0.56910795",... | 0.69360006 | 0 |
Ensure that the avatar to be returned to the client is jellyable and set up disconnection notification to call the realm's logout object. | def _cb_login(self, result):
(interface, avatar, logout) = result
if not IJellyable.providedBy(avatar):
avatar = AsReferenceable(avatar, "perspective")
puid = avatar.processUniqueID()
# only call logout once, whether the connection is dropped (disconnect)
# or a lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _authenticate_success(self, avatar):\r\n verifyObject(IRobot, avatar)\r\n verifyObject(IMessageReceiver, avatar)\r\n\r\n self._realm.registerWebsocketProtocol(avatar, self)\r\n self._avatar = avatar\r\n self._assembler.start()",
"def test_nonIAccountAvatar(self):\n\n ... | [
"0.5746234",
"0.5702337",
"0.56554294",
"0.5624332",
"0.5311794",
"0.52048504",
"0.5198731",
"0.5185655",
"0.5185307",
"0.51830447",
"0.51440936",
"0.5138373",
"0.51294583",
"0.5126391",
"0.50931156",
"0.50811464",
"0.50725645",
"0.5067577",
"0.5058934",
"0.50401604",
"0.5026... | 0.68438625 | 0 |
Attempt an anonymous login. | def remote_loginAnonymous(self, mind):
d = self.portal.login(Anonymous(), mind, IPerspective)
d.addCallback(self._cb_login)
d.addErrback(self._login_error)
return d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login_anonymously(self):\n username = b\"anonymous\"\n password = b\"anonymous\"\n self.send_cmd(b\"USER \" + username + B_CRLF)\n self.send_cmd(b\"PASS \" + password + B_CRLF)",
"def test_anonymous(self):\n self.logout_user()\n\n response = self.client.get(self.api_... | [
"0.84006125",
"0.67245954",
"0.6678382",
"0.6637545",
"0.659776",
"0.6503967",
"0.64948535",
"0.64948535",
"0.6493375",
"0.6464787",
"0.6442974",
"0.6442018",
"0.6401689",
"0.637059",
"0.6355611",
"0.6354807",
"0.63321805",
"0.6317234",
"0.6299916",
"0.62998486",
"0.6264222",... | 0.75659597 | 1 |
Add a differentiated environment remotely and bounce services. | def add_diff_env_to_controller(differentiated_environment):
env.host_string = ''.join(
[pytest.symbols.tenant_name,
'@',
pytest.symbols.controller_ip,
':22'])
@hosts(env.host_string)
def setup_env_oncontroller(diff_env):
env.password = pytest.symbols.tenant_passwo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_services(self):\n this_service = {'name': 'swift-proxy'}\n other_services = [\n {'name': 'percona-cluster'},\n {'name': 'keystone'},\n {'name': 'glance'},\n {'name': 'swift-storage'}\n ]\n super(SwiftProxyBasicDeployment, self)._add_s... | [
"0.61229914",
"0.60900104",
"0.58884495",
"0.5779385",
"0.57384515",
"0.56702316",
"0.5547591",
"0.55157214",
"0.5499751",
"0.54860777",
"0.54723555",
"0.5459061",
"0.54476196",
"0.5430527",
"0.5418114",
"0.5412822",
"0.5409647",
"0.540866",
"0.53975147",
"0.5396576",
"0.5395... | 0.6198412 | 0 |
Create a MACHeader object from binary representation. | def decode(cls, data):
h = struct.unpack('B', data)[0]
# Bits 7-5 define the message type
mtype = (h & 224) >> 5
# Bits 1-0 define the major version
major = h & 3
m = MACHeader(mtype, major)
return m | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_binary(cls, data):\n if isinstance(data, basestring):\n data = ctypes.c_buffer(data)\n return ctypes.cast(data, cls)",
"def FromBytes (cls, data):\n return cls (json.loads (zlib.decompress (data).decode ('utf-8')))",
"def from_bin(cls, bin):\n print(bin)\n ... | [
"0.63029975",
"0.6298211",
"0.6269471",
"0.6230406",
"0.6230406",
"0.6230406",
"0.6165754",
"0.6103863",
"0.6096166",
"0.6062224",
"0.60603344",
"0.605318",
"0.60463977",
"0.6030311",
"0.6015881",
"0.6011284",
"0.5973875",
"0.5953721",
"0.5924509",
"0.5880919",
"0.5880919",
... | 0.65674967 | 0 |
Create a MACPayload object from binary representation. | def decode(cls, data):
# Payload must be at a minimum 1 byte, + 7 byte fhdr
dlen = len(data)
# TODO: check region specific length
if dlen < 8:
raise DecodeError()
# Decode the frame header
fhdr = FrameHeader.decode(data)
# Check and decode fport
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_bytes(cls, bytes):\n construct = _constructs.Handshake.parse(bytes)\n return cls(\n msg_type=enums.HandshakeType(construct.msg_type),\n length=construct.length,\n body=cls._get_handshake_message(\n enums.HandshakeType(construct.msg_type), const... | [
"0.6090378",
"0.6090318",
"0.5978962",
"0.59704894",
"0.59683967",
"0.5935748",
"0.5911057",
"0.58509815",
"0.5818461",
"0.58011633",
"0.57986206",
"0.5792926",
"0.5736957",
"0.57289684",
"0.57289684",
"0.57289684",
"0.57159734",
"0.56825817",
"0.56807643",
"0.56807643",
"0.5... | 0.6768362 | 0 |
Check if message is a Join Request. | def isJoinRequest(self):
return self.mhdr.mtype == JOIN_REQUEST | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_can_join(self, user):\n if not user.is_active or user.is_anonymous():\n return False\n\n membership = self.check_membership(user)\n\n if membership is not None and not membership.is_left():\n return False # Already joined\n\n if self.join_condition == 'A... | [
"0.6452379",
"0.626594",
"0.61488986",
"0.60037756",
"0.57416487",
"0.5730546",
"0.5678724",
"0.5663459",
"0.5663459",
"0.562375",
"0.5586013",
"0.55756253",
"0.5568477",
"0.55624163",
"0.55541384",
"0.54828715",
"0.54662997",
"0.54185635",
"0.537057",
"0.5356909",
"0.5329553... | 0.84501 | 0 |
Check if message is a MAC Command. | def isMACCommand(self):
return self.payload.fport == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hasMACCommands(self):\n return hasattr(self, 'commands') and len(self.commands) > 0",
"def _mac_test(mac):\n\n\t\tif re.search(r'([0-9A-F]{2}[:]){5}([0-9A-F]){2}', mac.upper()) is not None:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn False",
"def isMac(cls, mac):\n return mac.startswith(cls.M... | [
"0.755947",
"0.672532",
"0.6640428",
"0.6533994",
"0.6505358",
"0.6296413",
"0.6254249",
"0.59940726",
"0.5959963",
"0.59316754",
"0.5778604",
"0.5717976",
"0.5717976",
"0.56823945",
"0.5681198",
"0.5666128",
"0.5655372",
"0.5639438",
"0.56337404",
"0.55934876",
"0.5592337",
... | 0.81563735 | 0 |
Check if the message has piggybacked MAC commands. | def hasMACCommands(self):
return hasattr(self, 'commands') and len(self.commands) > 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isMACCommand(self):\n return self.payload.fport == 0",
"def checkMac(self, mac):\n\t\tif mac in self.seenMacs:\n\t\t\treturn True\n\t\treturn False",
"def _mac_test(mac):\n\n\t\tif re.search(r'([0-9A-F]{2}[:]){5}([0-9A-F]){2}', mac.upper()) is not None:\n\t\t\treturn True\n\t\telse:\n\t\t\treturn Fa... | [
"0.7619544",
"0.6821711",
"0.6714587",
"0.6707917",
"0.6481048",
"0.5829702",
"0.5826408",
"0.5726994",
"0.5687967",
"0.5674971",
"0.5671705",
"0.5632995",
"0.56229925",
"0.5614518",
"0.5590094",
"0.5584571",
"0.55807775",
"0.55789894",
"0.55552274",
"0.55288565",
"0.54969895... | 0.8134334 | 0 |
Check if message is Unconfirmed Data Up. | def isUnconfirmedDataUp(self):
return self.mhdr.mtype == UN_DATA_UP | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isConfirmedDataUp(self):\n return self.mhdr.mtype == CO_DATA_UP",
"def _check_has_message(data):\r\n return re.match(r'^:[a-zA-Z0-9_]+\\![a-zA-Z0-9_]+@[a-zA-Z0-9_]+'\r\n r'\\.tmi\\.twitch\\.tv '\r\n r'PRIVMSG #[a-zA-Z0-9_]+ :.+$', data)",
"def tes... | [
"0.72619647",
"0.6033576",
"0.58653146",
"0.58089054",
"0.58089054",
"0.5776766",
"0.572533",
"0.57172453",
"0.57172453",
"0.5714736",
"0.571027",
"0.5690893",
"0.5690893",
"0.5685363",
"0.5674196",
"0.5648284",
"0.56379974",
"0.56021065",
"0.5599386",
"0.55659294",
"0.554126... | 0.80264497 | 0 |
Check if message is Confirmed Data Up. | def isConfirmedDataUp(self):
return self.mhdr.mtype == CO_DATA_UP | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isUnconfirmedDataUp(self):\n return self.mhdr.mtype == UN_DATA_UP",
"def is_confirmed(self):\n return self.state == TrackState.Confirmed",
"def is_confirmed(self):\n return self.state == TrackState.Confirmed",
"def test_mixed_messages_confirmed(self):\n appt_date = datetime.da... | [
"0.67213595",
"0.6520533",
"0.6520533",
"0.6263585",
"0.62301904",
"0.6225483",
"0.58551836",
"0.57706153",
"0.57688713",
"0.57369906",
"0.56558436",
"0.5643208",
"0.56357807",
"0.56081176",
"0.56081176",
"0.55899155",
"0.5582277",
"0.552938",
"0.55088836",
"0.55041903",
"0.5... | 0.7421025 | 0 |
Create a MACJoinRequestMessage object from binary representation. | def decode(cls, mhdr, data):
# Message (PHYPayload) must be 23 bytes
if len(data) != 23:
raise DecodeError()
(appeui, deveui, devnonce, mic) = struct.unpack('<QQHL', data[1:])
m = JoinRequestMessage(mhdr, appeui, deveui, devnonce, mic)
return m | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_bin(cls, bin):\n raw = msgpack.unpackb(bin, raw=False)\n event_msg = EventMessage.from_text(raw[\"event_message\"])\n msg = cls(\n uri_name=raw[\"uri_name\"],\n event_message=event_msg,\n publisher_connection_id=raw[\"publisher_connection_id\"]\n ... | [
"0.552725",
"0.5425762",
"0.5368403",
"0.5270291",
"0.5156768",
"0.5145092",
"0.5138449",
"0.5028855",
"0.4996436",
"0.499491",
"0.49865356",
"0.4965446",
"0.49050772",
"0.48789808",
"0.48702258",
"0.48655793",
"0.48603487",
"0.48333448",
"0.48247728",
"0.47453198",
"0.474390... | 0.6068377 | 0 |
Verify the message integrity code (MIC). The MIC is calculated over the binary join request message excluding the MIC. Use the first four bytes of AES CMAC encrypted data, convert from little endian data to int. | def checkMIC(self, appkey):
data = self.mhdr.encode() + struct.pack('<QQH', self.appeui,
self.deveui, self.devnonce)
aesdata = aesEncrypt(intPackBytes(appkey, 16), data, mode='CMAC')
mic = struct.unpack('<L', aesdata[:4])[0]
return mic == s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def checkMIC(self, key):\n\n # Calculate the MIC for this message using key\n msg = self.mhdr.encode() + self.payload.encode()\n B0 = struct.pack('<BLBLLBB',\n int('0x49', 16), 0, 0, self.payload.fhdr.devaddr,\n self.payload.fhdr.fcnt, 0, len(msg... | [
"0.71598995",
"0.64049065",
"0.56480235",
"0.5637347",
"0.5454202",
"0.54365945",
"0.53998774",
"0.5371131",
"0.52815175",
"0.51762164",
"0.51404285",
"0.5124289",
"0.51233184",
"0.49919683",
"0.4985628",
"0.49843112",
"0.49743018",
"0.49002138",
"0.48876262",
"0.486749",
"0.... | 0.6920435 | 1 |
Create a binary representation of JoinAcceptMessage object. | def encode(self):
# Encoding Join-accept:
# MAC Header
# 3 bytes appnonce
# 3 bytes netid
# 4 bytes devaddr
# 1 byte dlsettings
# 1 byte rxdelay
# Optional cflist
# Create the message
header = self.mhdr.encode()
msg = int... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_binary(self):\n c = containerize(exclude_fields(self))\n self.payload = MsgEd25519SignatureDepA._parser.build(c)\n return self.pack()",
"def to_binary(self):\n c = containerize(exclude_fields(self))\n self.payload = MsgEd25519SignatureDepB._parser.build(c)\n return self.pack()",
"def s... | [
"0.541406",
"0.5335521",
"0.53308",
"0.52956134",
"0.528599",
"0.5263396",
"0.5255439",
"0.52406186",
"0.52257687",
"0.52147436",
"0.51569605",
"0.5139693",
"0.5120897",
"0.5090103",
"0.50795907",
"0.5069714",
"0.49641097",
"0.49365515",
"0.4916861",
"0.4905223",
"0.49029097"... | 0.6395242 | 0 |
Encrypt FRMPayload The algorithm defines a sequence of Blocks Ai for i = 1..k with k = | def encrypt(self, key, dir):
if self.payload.frmpayload == None:
return
plen = len(self.payload.frmpayload)
if plen == 0:
return
k = int(math.ceil(plen/16.0))
# Create the concatenated block S
S = ''
for i in range(k):
# Ai: [0x... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _encrypt_block(self, v, k):\n DEBUG = GLOBAL_DEBUG and True\n if DEBUG: print \"_encrypt_block()\"\n\n v0 = struct.unpack(\"<L\", v[0:4])[0]\n v1 = struct.unpack(\"<L\", v[4:8])[0]\n delta = CRYPTO_DETLA; _sum = 0\n k0 = struct.unpack(\"<L\", k[ 0: 4])[0]\n k1 =... | [
"0.6701072",
"0.59162825",
"0.5883112",
"0.58597827",
"0.57845753",
"0.5760631",
"0.5733683",
"0.573238",
"0.57285607",
"0.5694037",
"0.5671513",
"0.5651121",
"0.5648157",
"0.5596295",
"0.5584826",
"0.55749476",
"0.55585885",
"0.5553993",
"0.55499274",
"0.5548845",
"0.5485306... | 0.6521654 | 1 |
Decrypt the MAC Data Uplink Message | def decrypt(self, key):
super(MACDataUplinkMessage, self).decrypt(key, dir=0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decrypt(self, data):",
"def decrypt(self, cipherText, additionalData=''):\n # warning only valid in the random oracle\n mac_key = sha2(b'Poor Mans Key Extractor'+self._key).digest()\n mac = MessageAuthenticator(mac_key)\n if not mac.verify(cipherText, additionalData=additionalData... | [
"0.7111976",
"0.6872339",
"0.67165786",
"0.66167766",
"0.65917337",
"0.65508085",
"0.6492593",
"0.6491689",
"0.6416149",
"0.63344264",
"0.6293553",
"0.6287138",
"0.6269033",
"0.6241707",
"0.62377435",
"0.62144214",
"0.6197449",
"0.61864007",
"0.6183186",
"0.6178265",
"0.61738... | 0.7834363 | 0 |
Create a LinkADRAns object from binary representation. | def decode(cls, data):
status = struct.unpack('B', data[1])[0]
# Power ACK is bit 2
power_ack = (status & 0x04) >> 2
# Datarate ACK is bit 1
datarate_ack = (status & 0x02) >> 1
# Channelmask ACK is bit 0
channelmask_ack = status & 0x01
return LinkADRAns(po... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_binary(self, d):\n p = MsgEcdsaSignatureDepA._parser.parse(d)\n for n in self.__class__.__slots__:\n setattr(self, n, getattr(p, n))",
"def isLinkADRAns(self):\n return self.cid == LINKADRANS",
"def __init__(self, ase):\n self.bin = open(ase, 'rb')",
"def from_bytes(cls, byt... | [
"0.5390176",
"0.52337843",
"0.5232689",
"0.5205826",
"0.51684314",
"0.51285547",
"0.5048815",
"0.5036541",
"0.5018804",
"0.5018804",
"0.5018804",
"0.4919265",
"0.49161735",
"0.49139756",
"0.4906276",
"0.48922858",
"0.4890763",
"0.48767224",
"0.48765296",
"0.4838343",
"0.48269... | 0.68051225 | 0 |
Transforms a prefixed name into a fully qualified name using a namespace map. Returns the name argument if it's not a prefixed name or if it has boolean value `False`. | def prefixed_to_qname(name, namespaces):
if not name or name[0] == '{':
return name
try:
prefix, name = name.split(':')
except ValueError:
if ':' in name:
raise XMLSchemaValueError("wrong format for reference name %r" % name)
try:
uri = namespaces['']... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def qname_to_prefixed(qname, namespaces):\n if not qname:\n return qname\n\n namespace = get_namespace(qname)\n for prefix, uri in sorted(filter(lambda x: x[1] == namespace, namespaces.items()), reverse=True):\n if not uri:\n return '%s:%s' % (prefix, qname) if prefix else qname\n... | [
"0.6176963",
"0.5939171",
"0.5878444",
"0.5772595",
"0.56936866",
"0.56378245",
"0.56071055",
"0.55428314",
"0.54875886",
"0.54137033",
"0.541037",
"0.5402979",
"0.54019225",
"0.53887755",
"0.5377738",
"0.5377038",
"0.5348816",
"0.53356695",
"0.5291961",
"0.5286983",
"0.52574... | 0.66310966 | 0 |
Transforms a fully qualified name into a prefixed name using a namespace map. Returns the qname argument if it's not a fully qualified name or if it has boolean value `False`. | def qname_to_prefixed(qname, namespaces):
if not qname:
return qname
namespace = get_namespace(qname)
for prefix, uri in sorted(filter(lambda x: x[1] == namespace, namespaces.items()), reverse=True):
if not uri:
return '%s:%s' % (prefix, qname) if prefix else qname
elif ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prefixed_to_qname(name, namespaces):\n if not name or name[0] == '{':\n return name\n\n try:\n prefix, name = name.split(':')\n except ValueError:\n if ':' in name:\n raise XMLSchemaValueError(\"wrong format for reference name %r\" % name)\n try:\n uri... | [
"0.6556813",
"0.62511295",
"0.59037846",
"0.577547",
"0.5698201",
"0.5667739",
"0.565227",
"0.5592783",
"0.5553025",
"0.5541053",
"0.539133",
"0.5390545",
"0.5350597",
"0.5306851",
"0.5299698",
"0.52917105",
"0.5291322",
"0.528414",
"0.525437",
"0.5212281",
"0.5172295",
"0.... | 0.70928234 | 0 |
Returns the annotation of an XSD component. | def get_xsd_annotation(elem):
try:
return elem[0] if elem[0].tag == XSD_ANNOTATION else None
except (TypeError, IndexError):
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getAnnotation(self, *args):\n return _libsbml.SBase_getAnnotation(self, *args)",
"def _get_annotation(cls, name):\n return cls.__annotations__.get(name)",
"def getAnnotationString(self, *args):\n return _libsbml.SBase_getAnnotationString(self, *args)",
"def dex_annotation(self):\n ... | [
"0.6144252",
"0.5947965",
"0.55147237",
"0.5450253",
"0.54219425",
"0.53904235",
"0.52879906",
"0.5248576",
"0.524548",
"0.52033925",
"0.5146348",
"0.50931776",
"0.5088037",
"0.5056364",
"0.5038453",
"0.50313544",
"0.50313544",
"0.5014017",
"0.49996793",
"0.4939668",
"0.49222... | 0.7735324 | 0 |
Returns an iterator for XSD child components, excluding the annotation. | def iter_xsd_components(elem, start=0):
counter = 0
for child in elem:
if child.tag == XSD_ANNOTATION:
if counter > 0:
raise XMLSchemaValueError("XSD annotation not allowed after the first position.")
else:
if start > 0:
start -= 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _filter_xml_iter(xml, ignored_nodes, ignored_attribs):\n for node in xml.iter():\n if node.tag.startswith('gfn_') and node.tag not in ignored_nodes:\n attribs = _pull_child_attribs(node)\n for attr, val in list(attribs.items()):\n if attr in ignored_attribs:\n ... | [
"0.6340484",
"0.6196724",
"0.6187818",
"0.6124669",
"0.5979975",
"0.59641093",
"0.5931766",
"0.5901007",
"0.5834058",
"0.5822961",
"0.5778663",
"0.57630765",
"0.57584244",
"0.57403934",
"0.571465",
"0.56969416",
"0.5686516",
"0.56425714",
"0.56354773",
"0.56321436",
"0.562279... | 0.6404322 | 0 |
Get an XML boolean attribute. | def get_xml_bool_attribute(elem, attribute, default=None):
value = elem.get(attribute, default)
if value is None:
raise XMLSchemaKeyError(attribute)
elif value in ('true', '1') or value is True:
return True
elif value in ('false', '0') or value is False:
return False
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_boolean_attribute_value(attrs, attr_name):\n return 1 if attrs.get(attr_name, 0) in [\"True\", \"1\"] else 0",
"def htmlIsBooleanAttr(name):\n ret = libxml2mod.htmlIsBooleanAttr(name)\n return ret",
"def bool_attr(attr):\n if attr.lower() == \"true\":\n val = True\n elif attr.lowe... | [
"0.8068364",
"0.79504746",
"0.7846916",
"0.7808149",
"0.7275484",
"0.71687293",
"0.7158612",
"0.71346104",
"0.68129945",
"0.6649268",
"0.66359484",
"0.65509516",
"0.6544878",
"0.6528472",
"0.6522647",
"0.6521496",
"0.64927465",
"0.64832646",
"0.6477126",
"0.6466215",
"0.64166... | 0.81031615 | 0 |
Get a derivation attribute (maybe 'block', 'blockDefault', 'final' or 'finalDefault') checking the items with the values arguments. Returns a string. | def get_xsd_derivation_attribute(elem, attribute, values):
value = elem.get(attribute, '')
items = value.split()
if len(items) == 1 and items[0] == '#all':
return ' '.join(values)
elif not all([s in values for s in items]):
raise XMLSchemaValueError("wrong value %r for attribute %r." % (... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_attr(cls, dset, name, default=None):\n dec = default\n if name in dset.attrs:\n raw = dset.attrs[name]\n if (sys.version_info[0] > 2) and (\"decode\" in dir(raw)):\n dec = raw.decode()\n else:\n dec = raw\n return dec",
"... | [
"0.6131019",
"0.58951485",
"0.5793569",
"0.5699241",
"0.56671786",
"0.565939",
"0.5624805",
"0.5510728",
"0.55054855",
"0.5497727",
"0.54553944",
"0.5420734",
"0.5420734",
"0.5416554",
"0.5416554",
"0.5399205",
"0.5385788",
"0.5379691",
"0.53795564",
"0.53759485",
"0.5365908"... | 0.61691767 | 0 |
Get the xpathDefaultNamespace attribute value for alternative, assert, assertion, selector and field XSD 1.1 declarations, checking if the value is conforming to the specification. | def get_xpath_default_namespace(elem, default_namespace, target_namespace, default=None):
value = elem.get('xpathDefaultNamespace')
if value is None:
return default
value = value.strip()
if value == '##local':
return ''
elif value == '##defaultNamespace':
return default_name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_xpath_default_namespace(self, elem: ElementType) -> str:\n try:\n value = elem.attrib['xpathDefaultNamespace']\n except KeyError:\n return ''\n\n value = value.strip()\n if value == '##local':\n return ''\n elif value == '##defaultNames... | [
"0.7544338",
"0.67855847",
"0.6565186",
"0.6310704",
"0.6000959",
"0.5874823",
"0.5874823",
"0.5795311",
"0.57128567",
"0.56962854",
"0.5689608",
"0.5678486",
"0.5616536",
"0.56114686",
"0.5604249",
"0.5591755",
"0.55597186",
"0.55516267",
"0.55041003",
"0.5496849",
"0.547730... | 0.7747864 | 0 |
Set up learner group model in datastore for use in testing. | def setUp(self) -> None:
super().setUp()
self.learner_group_model = learner_group_models.LearnerGroupModel(
id='learner_group_32',
title='title',
description='description',
facilitator_user_ids=['facilitator_1', 'facilitator_2'],
learner_user_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self) -> None:\n super().setUp()\n\n user_models.LearnerGoalsModel(\n id=self.USER_1_ID,\n topic_ids_to_learn=self.TOPIC_IDS,\n topic_ids_to_master=[]\n ).put()\n user_models.LearnerGoalsModel(\n id=self.USER_2_ID,\n topic... | [
"0.61293876",
"0.59921515",
"0.587601",
"0.574717",
"0.5718404",
"0.56846803",
"0.56846803",
"0.56830806",
"0.5641271",
"0.5619335",
"0.5580495",
"0.555598",
"0.55516076",
"0.5527176",
"0.551655",
"0.5513867",
"0.5513867",
"0.55038404",
"0.5503731",
"0.5486551",
"0.54782766",... | 0.76751816 | 0 |
Test export data on users that are learners of the learner group. | def test_export_data_on_learners(self) -> None:
learner_user_data = (
learner_group_models.LearnerGroupModel.export_data('learner_1'))
expected_learner_user_data = {
'learner_group_32': {
'title': 'title',
'description': 'description',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_export_data_on_facilitators(self) -> None:\n facilitator_user_data = (\n learner_group_models.LearnerGroupModel.export_data('facilitator_1')\n )\n expected_facilitator_user_data = {\n 'learner_group_32': {\n 'title': 'title',\n 'desc... | [
"0.7391453",
"0.71599096",
"0.69906294",
"0.67107385",
"0.6427581",
"0.62387043",
"0.619788",
"0.61037135",
"0.6060703",
"0.6058318",
"0.5976969",
"0.5963713",
"0.58915544",
"0.57673866",
"0.57594997",
"0.57401276",
"0.57365906",
"0.5736579",
"0.5720988",
"0.5720746",
"0.5717... | 0.82546306 | 0 |
Test export data on learners that have been invited to join the learner group. | def test_export_data_on_invited_learners(self) -> None:
invited_learner_data = (
learner_group_models.LearnerGroupModel.export_data(
'invited_user_2'))
expected_invited_learner_data = {
'learner_group_32': {
'title': 'title',
'descr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_export_data_on_learners(self) -> None:\n\n learner_user_data = (\n learner_group_models.LearnerGroupModel.export_data('learner_1'))\n expected_learner_user_data = {\n 'learner_group_32': {\n 'title': 'title',\n 'description': 'description',... | [
"0.76291746",
"0.68613166",
"0.643133",
"0.6335562",
"0.5829565",
"0.5827247",
"0.5816315",
"0.5793037",
"0.56027234",
"0.5601156",
"0.5576441",
"0.55700135",
"0.555205",
"0.55247283",
"0.54877746",
"0.5469886",
"0.541608",
"0.53515536",
"0.5345908",
"0.53125596",
"0.53118473... | 0.79540646 | 0 |
Test export data on users that are facilitators of the learner group. | def test_export_data_on_facilitators(self) -> None:
facilitator_user_data = (
learner_group_models.LearnerGroupModel.export_data('facilitator_1')
)
expected_facilitator_user_data = {
'learner_group_32': {
'title': 'title',
'description': 'd... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_export_data_on_learners(self) -> None:\n\n learner_user_data = (\n learner_group_models.LearnerGroupModel.export_data('learner_1'))\n expected_learner_user_data = {\n 'learner_group_32': {\n 'title': 'title',\n 'description': 'description',... | [
"0.7347017",
"0.68044364",
"0.64552635",
"0.64420795",
"0.64139664",
"0.6333079",
"0.6322606",
"0.627509",
"0.6167357",
"0.6062882",
"0.60312575",
"0.59792536",
"0.5963009",
"0.595865",
"0.5947541",
"0.5931794",
"0.59228253",
"0.59050244",
"0.58752257",
"0.577503",
"0.5755452... | 0.7944413 | 0 |
Test export data on users who do not have any involvement with the learner group. | def test_export_data_on_uninvolved_user(self) -> None:
uninvolved_user_data = (
learner_group_models.LearnerGroupModel.export_data('learner_21'))
expected_uninvolved_user_data: Dict[str, Union[str, List[str]]] = {}
self.assertEqual(
expected_uninvolved_user_data,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_export_data_on_existent_user(self) -> None:\n user_data = (\n user_models.LearnerGoalsModel.export_data(self.USER_1_ID))\n expected_data = {\n 'topic_ids_to_learn': self.TOPIC_IDS,\n 'topic_ids_to_master': []\n }\n self.assertEqual(expected_data... | [
"0.7515585",
"0.7166726",
"0.6966799",
"0.6956122",
"0.69056755",
"0.6778866",
"0.669259",
"0.6655868",
"0.6649562",
"0.65800077",
"0.6574551",
"0.64383256",
"0.6425773",
"0.64105016",
"0.63345814",
"0.6261518",
"0.6236627",
"0.6224624",
"0.62146187",
"0.6214548",
"0.6101231"... | 0.7234459 | 1 |
Test apply_deletion_policy on users that are learners of the learner group. | def test_apply_deletion_policy_on_learners(self) -> None:
self.assertTrue(
learner_group_models.LearnerGroupModel
.has_reference_to_user_id('learner_1'))
learner_group_models.LearnerGroupModel.apply_deletion_policy(
'learner_1')
self.assertFalse(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_apply_deletion_policy_on_facilitators(self) -> None:\n self.assertTrue(\n learner_group_models.LearnerGroupModel\n .has_reference_to_user_id('facilitator_1'))\n self.assertTrue(\n learner_group_models.LearnerGroupModel\n .has_reference_to_user_id('... | [
"0.7817379",
"0.775673",
"0.6340133",
"0.62567496",
"0.6241089",
"0.6241089",
"0.61621666",
"0.616183",
"0.61173344",
"0.61173344",
"0.60957557",
"0.60106057",
"0.5986533",
"0.5947031",
"0.59386224",
"0.5913165",
"0.5913165",
"0.58748037",
"0.5860952",
"0.5822123",
"0.5816133... | 0.871566 | 0 |
Test apply_deletion_policy on users that have been invited to join the learner group. | def test_apply_deletion_policy_on_invited_users(self) -> None:
self.assertTrue(
learner_group_models.LearnerGroupModel
.has_reference_to_user_id('invited_user_1'))
learner_group_models.LearnerGroupModel.apply_deletion_policy(
'invited_user_1')
self.assertFal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_apply_deletion_policy_on_learners(self) -> None:\n self.assertTrue(\n learner_group_models.LearnerGroupModel\n .has_reference_to_user_id('learner_1'))\n\n learner_group_models.LearnerGroupModel.apply_deletion_policy(\n 'learner_1')\n\n self.assertFalse... | [
"0.79934746",
"0.74297476",
"0.62506926",
"0.62506926",
"0.61869216",
"0.61869216",
"0.60836464",
"0.6055344",
"0.6010275",
"0.5990391",
"0.59842926",
"0.5982131",
"0.5980436",
"0.5966811",
"0.59628314",
"0.59582776",
"0.5957713",
"0.5931597",
"0.5922003",
"0.59136575",
"0.59... | 0.86765325 | 0 |
Test apply_deletion_policy on users that are facilitators of the learner group. | def test_apply_deletion_policy_on_facilitators(self) -> None:
self.assertTrue(
learner_group_models.LearnerGroupModel
.has_reference_to_user_id('facilitator_1'))
self.assertTrue(
learner_group_models.LearnerGroupModel
.has_reference_to_user_id('facilitator... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_apply_deletion_policy_on_learners(self) -> None:\n self.assertTrue(\n learner_group_models.LearnerGroupModel\n .has_reference_to_user_id('learner_1'))\n\n learner_group_models.LearnerGroupModel.apply_deletion_policy(\n 'learner_1')\n\n self.assertFalse... | [
"0.8157202",
"0.74588156",
"0.63956034",
"0.63956034",
"0.62298506",
"0.62129825",
"0.62129825",
"0.6149048",
"0.6141736",
"0.61258495",
"0.61251056",
"0.60858184",
"0.6047559",
"0.6011636",
"0.59840035",
"0.5983727",
"0.5983727",
"0.597598",
"0.59205806",
"0.5919736",
"0.590... | 0.83890605 | 0 |
Optimize and write a solution for a given return. | def optimizeForReturn(required_return, stock_db, use_genetic):
print('Optimizing portfolio for %f' % required_return)
pf = PortfolioFactory(stock_db, required_return, use_genetic=use_genetic)
desired_portfolio = pf.desired_portfolio
print('Required Return: %f' % required_return)
print('Expected Retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self, **kwargs) -> OptimizationResult:\n raise NotImplementedError",
"def propose_optimize():\n pass",
"def accept_optimize():\n pass",
"def optimal_return(self, target_return):\n\n target_risk = 2 * (target_return - self._A /\n self._C) * self._C / sel... | [
"0.6112539",
"0.5957103",
"0.5798812",
"0.57311904",
"0.56137687",
"0.56022626",
"0.55822736",
"0.55729073",
"0.55622846",
"0.54892087",
"0.5383227",
"0.53796405",
"0.5373764",
"0.5355513",
"0.53491026",
"0.5337703",
"0.5303542",
"0.52541196",
"0.5246625",
"0.52183515",
"0.51... | 0.6827331 | 0 |
Generate a selfies string from a list of selfies characters. | def sc2selfies(chromosome):
selfie = "".join(x for x in list(chromosome))
return selfie | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any_of_chars(*args:List[str]) -> str:\n # TODO uniq\n chars = \"\".join(args)\n return f\"[{chars}]\"",
"def gen_chars(length, character):\n return ''.join([character for i in range(length)])",
"def create_word(char_list):",
"def generate_strings(char_list, length):\n if length <= 0:\n ... | [
"0.66244525",
"0.6480856",
"0.63885796",
"0.62456566",
"0.6172557",
"0.6162482",
"0.6138795",
"0.6096619",
"0.6092695",
"0.59446263",
"0.5893259",
"0.5849113",
"0.58410794",
"0.5823533",
"0.5820577",
"0.5819071",
"0.57618475",
"0.5757863",
"0.57357454",
"0.5731963",
"0.572316... | 0.6632098 | 0 |
Test unnamed parameterized test cases. Unnamed parameterized test cases might have nonalphanumeric characters in their test method names. This test ensures xml_reporter handles them correctly. | def test_unnamed_parameterized_testcase(self):
class ParameterizedTest(parameterized.TestCase):
@parameterized.parameters(('a (b.c)',))
def test_prefix(self, case):
self.assertTrue(case.startswith('a'))
start_time = 1000
end_time = 1200
result = self._make_result((start_time, star... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_method(self, test, another_test, _): # noqa: D213, D407",
"def test_named_unit_before_fmt_error():\n tcls = Write_Stmt\n # Cannot have an un-named (positional) argument after a named argument\n with pytest.raises(NoMatchError):\n tcls('''WRITE (UNIT=6, '(\"write some=\"\"'//'text'//'\"\... | [
"0.6007048",
"0.57684636",
"0.5733327",
"0.5722471",
"0.5707231",
"0.5693226",
"0.56390965",
"0.55979824",
"0.5574163",
"0.5541929",
"0.5538383",
"0.5538148",
"0.5526179",
"0.5503503",
"0.5493446",
"0.5406374",
"0.5373537",
"0.5366877",
"0.5366877",
"0.53375703",
"0.53303295"... | 0.6620986 | 0 |
Make sure that timing is correct even if time.time is stubbed out. | def test_timing_with_time_stub(self):
saved_time = time.time
try:
time.time = lambda: -1
reporter = xml_reporter._TextAndXMLTestResult(self.xml_stream,
self.stream,
'foo', 0)
test = MockTest... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_time(self):\r\n pass",
"def mocked_time():\n return datetime.datetime(2017, 10, 27, 22, 54, 56, 566179)",
"def mock_time(desired_time):\n # type: (float) -> Any\n return mock.patch.object(time, 'time', return_value=desired_time)",
"def test_issue_tracked_times(self):\n pass",
... | [
"0.75045544",
"0.7157744",
"0.71284795",
"0.7042834",
"0.67543995",
"0.6729279",
"0.66934484",
"0.668006",
"0.66573656",
"0.65454465",
"0.64997685",
"0.64811856",
"0.64714813",
"0.6441179",
"0.6407118",
"0.64055526",
"0.63309836",
"0.6326087",
"0.6317468",
"0.6312589",
"0.629... | 0.7484447 | 1 |
Make sure adding/deleting pending test case results are thread safe. | def test_concurrent_add_and_delete_pending_test_case_result(self):
result = xml_reporter._TextAndXMLTestResult(None, self.stream, None, 0,
None)
def add_and_delete_pending_test_case_result(test_name):
test = MockTest(test_name)
result.addSuccess(test)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_concurrent_test_runs(self):\n num_passing_tests = 20\n num_failing_tests = 20\n num_error_tests = 20\n total_num_tests = num_passing_tests + num_failing_tests + num_error_tests\n\n times = [0] + [i for i in range(2 * total_num_tests)\n ] + [2 * total_num_tests - 1]\n res... | [
"0.5883735",
"0.586215",
"0.57313365",
"0.57146406",
"0.57077146",
"0.5666658",
"0.56438947",
"0.5643743",
"0.56395847",
"0.56367725",
"0.56336904",
"0.5619068",
"0.5575947",
"0.5566781",
"0.5549457",
"0.5534746",
"0.5531143",
"0.5527226",
"0.55156374",
"0.5504255",
"0.549787... | 0.8176419 | 0 |
Make sure concurrent test runs do not race each other. | def test_concurrent_test_runs(self):
num_passing_tests = 20
num_failing_tests = 20
num_error_tests = 20
total_num_tests = num_passing_tests + num_failing_tests + num_error_tests
times = [0] + [i for i in range(2 * total_num_tests)
] + [2 * total_num_tests - 1]
result = self._m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_concurrent_threads(self):\n tid1 = 'd551573a-01dc-41b2-b197-ea8afb7fbac1'.replace('-', '')\n tid2 = '6c006821-0cb1-42e8-8ab1-fb6e059cabab'.replace('-', '')\n stacks = []\n tids = []\n\n def append_to_context():\n # print('@gcs=0x{:0X} @gcs.tracer_id=0x{:0X}'.f... | [
"0.65429026",
"0.6472724",
"0.6467191",
"0.6427281",
"0.641334",
"0.63857484",
"0.637222",
"0.6304564",
"0.6295698",
"0.6277324",
"0.62303114",
"0.6221869",
"0.6211624",
"0.62009317",
"0.6192972",
"0.60831636",
"0.6083111",
"0.60616803",
"0.6052305",
"0.6017978",
"0.5979822",... | 0.68643814 | 0 |
Tests an addFailure() call from within a stopTest() call stack. | def test_add_failure_during_stop_test(self):
result = self._make_result((0, 2))
test = MockTest('__main__.MockTest.failing_test')
result.startTestRun()
result.startTest(test)
# Replace parent stopTest method from unittest.TextTestResult with
# a version that calls self.addFailure().
with mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addFailure(self, test, err):\r\n self.failures.append((test, self._exc_info_to_string(err, test)))\r\n self._mirrorOutput = True",
"def addFailure(self, result):\n result.addFailure(self, (Exception, Exception(), None))\n # Since TAP will not provide assertion data, clean up the a... | [
"0.73454225",
"0.7325358",
"0.7311755",
"0.7295425",
"0.7277555",
"0.72115463",
"0.7013161",
"0.6990844",
"0.6955256",
"0.692801",
"0.6777787",
"0.6773905",
"0.67609555",
"0.67245877",
"0.67044",
"0.6697172",
"0.6694828",
"0.6693695",
"0.6630421",
"0.65596807",
"0.65556216",
... | 0.82049626 | 0 |
Runs xml_reporter_helper_test and returns an Element instance. Runs xml_reporter_helper_test in a new process so that it can exercise the entire test infrastructure, and easily test issues in the test fixture. | def _run_test_and_get_xml(self, flag):
xml_fhandle, xml_fname = tempfile.mkstemp()
os.close(xml_fhandle)
try:
binary = self._get_helper()
args = [binary, flag, '--xml_output_file=%s' % xml_fname]
ret = subprocess.call(args)
self.assertEqual(ret, 0)
xml = ElementTree.parse(xm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, test):\n class_ = test.__class__\n classname = class_.__module__ + '.' + class_.__name__\n if self._stream is None:\n filename = 'TEST-%s.xml' % classname\n stream = open(os.path.join(self._path, filename), 'w')\n stream.write('<?xml version=\"1.0... | [
"0.58988667",
"0.5218374",
"0.5207447",
"0.5137851",
"0.51036584",
"0.5059844",
"0.50535077",
"0.49125212",
"0.4905094",
"0.4853212",
"0.48081622",
"0.47982147",
"0.47859952",
"0.47683552",
"0.47624856",
"0.4748779",
"0.47414392",
"0.47389653",
"0.46894652",
"0.4687508",
"0.4... | 0.6627483 | 0 |
Test that `generate_token` produces a 40char token string. | def test_generate_token(self):
door_pass = DoorPassFactory.build()
token = door_pass.generate_token()
self.assertIsInstance(token, str)
self.assertEqual(len(token), 40) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generateToken():\n token_length = random.randint(MIN_TOKEN_LEN, MAX_TOKEN_LEN)\n token = ''.join(random.choice(POSS_TOKEN_CHARS) for _ in range(token_length))\n return token",
"def generateToken():\n length = random.randint(8, 32)\n rdmtoken = ''.join(random.choice(string.printable) for i in r... | [
"0.7631524",
"0.76217407",
"0.7389145",
"0.7389145",
"0.7382145",
"0.70968497",
"0.70874554",
"0.68096155",
"0.68015397",
"0.67370415",
"0.6688642",
"0.6678661",
"0.66173416",
"0.66071784",
"0.6533604",
"0.6524255",
"0.64557093",
"0.6450354",
"0.64336383",
"0.64093226",
"0.63... | 0.83542496 | 0 |
Test that `save` adds a value for `token`. | def test_save(self):
door_pass = DoorPassFactory.build(token=None, device=self.device)
door_pass.save()
self.assertIsNotNone(door_pass.token) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveToken(self, token):\n query = \"INSERT OR REPLACE INTO token (token, id) VALUES (?, 1)\"\n self.db.execute(query, (token,))",
"def save_token(self):\n db.session.add(self)\n db.session.commit()",
"def save_token(self):\n if self.token is None:\n raise Value... | [
"0.6854037",
"0.6585805",
"0.655561",
"0.6528274",
"0.6317411",
"0.6317411",
"0.62362045",
"0.6181603",
"0.6117558",
"0.6033591",
"0.59735185",
"0.5964317",
"0.58679295",
"0.5859858",
"0.58448577",
"0.58244234",
"0.5803811",
"0.57872754",
"0.578104",
"0.57757235",
"0.57051265... | 0.6970761 | 0 |
Test that `is_expired` works correctly when only using time based expiration. | def test_is_expired_time_based(self):
expired_dt = datetime.now() + timedelta(hours=-1)
good_dt = datetime.now() + timedelta(hours=1)
expired_pass = DoorPassFactory.create(device=self.device, expires_at=expired_dt)
good_pass = DoorPassFactory.create(device=self.device, expires_at=good_dt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_expired(self):\n return self.expiration_date <= self._now()",
"def is_expired(self):\n return utcnow() >= self.expires",
"def is_expired(self) -> bool:\n return now() > self.expires",
"def is_expired(self):\n return timeutils.utcnow_ts() > self.expire_ts",
"def has_expire... | [
"0.810299",
"0.80347586",
"0.7965115",
"0.7939916",
"0.7937447",
"0.7911585",
"0.7794946",
"0.7765188",
"0.7733985",
"0.76858866",
"0.7651386",
"0.76299185",
"0.7628304",
"0.75381833",
"0.7531072",
"0.7483425",
"0.74437714",
"0.7441658",
"0.738121",
"0.73680216",
"0.7322497",... | 0.8274048 | 0 |
Strips the whitespace from a SAX parser list for a feed. | def strip_whitespace(enclosing_tag, all_parts):
if 'feed' in enclosing_tag:
first_part = ''.join(all_parts[:-3]).strip('\n\r\t ')
return '%s\n</%s>' % (first_part, enclosing_tag)
else:
first_part = ''.join(all_parts[:-3]).strip('\n\r\t ')
channel_part = first_part.rfind('</channel>')
if channel_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _StripWS(s):\r\n return re.sub('\\s+', '', s)",
"def _StripWS(s):\r\n return re.sub('\\s+', '', s)",
"def strip_whitespace(stream):\n while not stream.eof() and stream.peek() in WHITESPACE:\n stream.consume()",
"def stripl(l):\n return filter(lambda x:x, map(lambda x: x.strip(), l))",
"d... | [
"0.60335314",
"0.60335314",
"0.597882",
"0.5940232",
"0.5939875",
"0.58296335",
"0.5795171",
"0.5775989",
"0.577361",
"0.575461",
"0.5644217",
"0.55774194",
"0.55756056",
"0.55497086",
"0.55285925",
"0.5527213",
"0.5508785",
"0.5503142",
"0.54743665",
"0.5449471",
"0.5427361"... | 0.6068497 | 0 |
If a new Profile is created when parsing matches, use the Blizzard API to fetch the player details (name, avatar, clan etc) in a celery task. | def profile_get_details(sender, instance, created, **kwargs):
if created:
return get_profile_details.delay(instance.id) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_player_bio(self, player_id):\n logging.info('updating player profile : {}'.format(player_id))\n player_profile_summary_url = \"{}{}{}\".format(self.base_url, self.overview, player_id)\n bio_page = requests.get(player_profile_summary_url)\n if int(bio_page.status_code) != 200:\n ... | [
"0.6043476",
"0.5604107",
"0.55719465",
"0.55146104",
"0.5486825",
"0.5485518",
"0.54694116",
"0.5383637",
"0.53265053",
"0.52277905",
"0.5224399",
"0.5178164",
"0.5164591",
"0.5163777",
"0.5155247",
"0.5145751",
"0.51390564",
"0.51383746",
"0.5105429",
"0.51046246",
"0.50853... | 0.5817143 | 1 |
Handle cleanup of S3 file to auto delete the replay if the record is removed. | def replay_delete(sender, instance, **kwargs):
pass
# Temporarily disabled
#print("deleting file from S3")
# False so FileField doesn't save the model
#instance.file.delete(False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s3_delete_data(self):\n\n self.k.delete()",
"def rm(self, filename: str) -> None:\n\n now = datetime.datetime.utcnow()\n timestamp = now.strftime('%a, %d %b %Y %H:%M:%S GMT')\n headers = [\n ('Connection', 'keep-alive'),\n ('Content-Length', '0'),\n ('... | [
"0.69838834",
"0.68269145",
"0.6758412",
"0.6655352",
"0.6648379",
"0.6645472",
"0.64110625",
"0.63995767",
"0.63821363",
"0.63692516",
"0.6335809",
"0.6334911",
"0.6276309",
"0.6251241",
"0.624855",
"0.6230804",
"0.6226007",
"0.62069464",
"0.61938834",
"0.6187478",
"0.617878... | 0.7129995 | 0 |
Fires whenever a new match is made. We'll serialize a response with this and Rosters as they are most commonly used. | def new_match(sender, instance: Match, **kwargs):
log.debug('in new_match signal')
match = serializers.MatchFullSerializer(instance).data
streamers = serializers.MatchStreamersSerializer(instance.streamers, many=True).data
payload = {
'match': match,
'streamers': streamers
}
lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_response(self, response):\n if log.isEnabledFor(logging.DEBUG):\n log.debug(\n 'RESPONSE MESSAGE RECEIVED %s %s',\n repr(self),\n response,\n )\n\n self.response_queue.put(response)",
"def add_match(self, match):\n\n #... | [
"0.579904",
"0.5798517",
"0.5765444",
"0.5556632",
"0.55552924",
"0.555286",
"0.5543297",
"0.55384946",
"0.5533414",
"0.551364",
"0.5505132",
"0.5456187",
"0.5427019",
"0.5404269",
"0.53044367",
"0.526851",
"0.5268182",
"0.5240167",
"0.523125",
"0.523125",
"0.52067184",
"0.... | 0.6845934 | 0 |
trace should be a [(command,new_state)]. returns a list of (state, command) | def makeTrainingExamples(trace):
current = SimpleBrep()
spec = trace[-1][1]
examples = []
for command, new_state in trace + [("RETURN",spec)]:
state = Object.extract(current, False) + Object.extract(spec, True)
def horizontalPointer(x):
try:
x = float(x)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trace_back(self, node):\n state_id = node.get_state_id()\n steps = [eval(state_id)]\n if state_id in self._history:\n previous = self._history[state_id]\n else:\n previous = False\n while previous:\n steps.append(eval(previous))\n i... | [
"0.63532573",
"0.546512",
"0.543561",
"0.54202884",
"0.53788763",
"0.5331027",
"0.5313868",
"0.5308481",
"0.525943",
"0.5250573",
"0.5245383",
"0.5218812",
"0.5205254",
"0.51712465",
"0.51658404",
"0.5163766",
"0.5139943",
"0.5103275",
"0.50918037",
"0.5078503",
"0.5077387",
... | 0.5497714 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.