lines
sequencelengths 1
444
| raw_lines
sequencelengths 1
444
| label
sequencelengths 1
444
| type
sequencelengths 1
444
|
|---|---|---|---|
[
"@VAR_15...\n",
"log.msg('Error while rendering http %s', system='httprest')\n",
"log.err(VAR_16, system='httprest')\n"
] | [
"@deferred...\n",
"log.msg('Error while rendering http %s', system='httprest')\n",
"log.err(error, system='httprest')\n"
] | [
0,
0,
0
] | [
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_6(VAR_2):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_6 = FUNC_0(VAR_2)\n",
"VAR_7 = FUNC_1(VAR_2)\n",
"VAR_9 = [VAR_2, VAR_6, VAR_7]\n",
"VAR_1.execute('INSERT INTO files VALUES (NULL, %s, %s, %s, 0, 0);', VAR_9)\n",
"VAR_0.commit()\n",
"return\n"
] | [
"def db_insert_new_file(path):...\n",
"\"\"\"docstring\"\"\"\n",
"file_size = get_file_size(path)\n",
"file_age = get_file_age(path)\n",
"params = [path, file_size, file_age]\n",
"cur.execute('INSERT INTO files VALUES (NULL, %s, %s, %s, 0, 0);', params)\n",
"db.commit()\n",
"return\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Return'"
] |
[
"def FUNC_3(VAR_0):...\n",
"VAR_2 = []\n",
"VAR_5 = {}\n",
"VAR_6 = 's.transaction_date' if VAR_0['based_on'\n ] == 'Sales Order' else 's.posting_date'\n",
"VAR_7 = frappe.db.sql('string'.format(VAR_6=date_field, doctype=filters[\n 'based_on']), as_dict=1)\n",
"for d in VAR_7:\n",
"VAR_5.setdefault(d.item_name, d)\n",
"return VAR_5\n"
] | [
"def get_sales_details(filters):...\n",
"data = []\n",
"item_details_map = {}\n",
"date_field = 's.transaction_date' if filters['based_on'\n ] == 'Sales Order' else 's.posting_date'\n",
"sales_data = frappe.db.sql(\n \"\"\"\n\t\tselect s.territory, s.customer, si.item_group, si.item_name, si.qty, {date_field} as last_order_date,\n\t\tDATEDIFF(CURDATE(), {date_field}) as days_since_last_order\n\t\tfrom `tab{doctype}` s, `tab{doctype} Item` si\n\t\twhere s.name = si.parent and s.docstatus = 1\n\t\tgroup by si.name order by days_since_last_order \"\"\"\n .format(date_field=date_field, doctype=filters['based_on']), as_dict=1)\n",
"for d in sales_data:\n",
"item_details_map.setdefault(d.item_name, d)\n",
"return item_details_map\n"
] | [
0,
0,
0,
0,
4,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Expr'",
"Return'"
] |
[
"def __init__(self, VAR_3=None):...\n",
"\"\"\"docstring\"\"\"\n",
"self.ime_property_cache = {}\n",
"if VAR_3.find('typing-booster:') > 0:\n",
"VAR_3 = VAR_3.replace('typing-booster:', '')\n",
"if os.path.exists(VAR_3) and os.path.isfile(VAR_3):\n",
"VAR_23 = re.compile('^#')\n",
"sys.stderr.write('Error: ImeProperties: No such file: %s' % VAR_3)\n",
"for line in file(VAR_3):\n",
"if not VAR_23.match(line):\n",
"VAR_57, VAR_58 = line.strip().split('=', 1)\n",
"self.ime_property_cache[VAR_57.strip()] = VAR_58.strip()\n"
] | [
"def __init__(self, configfile_path=None):...\n",
"\"\"\"docstring\"\"\"\n",
"self.ime_property_cache = {}\n",
"if configfile_path.find('typing-booster:') > 0:\n",
"configfile_path = configfile_path.replace('typing-booster:', '')\n",
"if os.path.exists(configfile_path) and os.path.isfile(configfile_path):\n",
"comment_patt = re.compile('^#')\n",
"sys.stderr.write('Error: ImeProperties: No such file: %s' % configfile_path)\n",
"for line in file(configfile_path):\n",
"if not comment_patt.match(line):\n",
"attr, val = line.strip().split('=', 1)\n",
"self.ime_property_cache[attr.strip()] = val.strip()\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Expr'",
"For",
"Condition",
"Assign'",
"Assign'"
] |
[
"def FUNC_2(VAR_9):...\n",
"\"\"\"docstring\"\"\"\n",
"if isinstance(VAR_9, str):\n",
"return VAR_9\n",
"if isinstance(VAR_9, unicode):\n",
"return VAR_9.encode('utf-8')\n",
"return str(VAR_9)\n"
] | [
"def _ConvertToAscii(value):...\n",
"\"\"\"docstring\"\"\"\n",
"if isinstance(value, str):\n",
"return value\n",
"if isinstance(value, unicode):\n",
"return value.encode('utf-8')\n",
"return str(value)\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Return'",
"Condition",
"Return'",
"Return'"
] |
[
"def __call__(self, *VAR_5, **VAR_6):...\n",
"return CLASS_6(self.key_name, *VAR_5, **kwargs)\n"
] | [
"def __call__(self, *args, **kwargs):...\n",
"return JsonKeyTransform(self.key_name, *args, **kwargs)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"@integration_synonym_api...\n",
"FUNC_2(VAR_2)\n",
"FUNC_3(VAR_2, 'PNEU', VAR_7='1')\n",
"FUNC_5(VAR_4, VAR_5, VAR_11='NEU', VAR_10=[{'name': '----NEU'}, {'name':\n 'PNEU'}])\n"
] | [
"@integration_synonym_api...\n",
"clean_database(solr)\n",
"seed_database_with(solr, 'PNEU', id='1')\n",
"verify_results(client, jwt, query='NEU', expected=[{'name': '----NEU'}, {\n 'name': 'PNEU'}])\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_29(VAR_42):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_42 = str(VAR_42)\n",
"if len(VAR_42) < 4:\n",
"VAR_42 += '__'\n",
"VAR_54 = VAR_42[0:3]\n",
"VAR_55 = VAR_42[3].replace('_', '')\n",
"VAR_56 = VAR_42[4].replace('_', '')\n",
"return VAR_54, VAR_55, VAR_56\n"
] | [
"def _parse_marc_code(field):...\n",
"\"\"\"docstring\"\"\"\n",
"field = str(field)\n",
"if len(field) < 4:\n",
"field += '__'\n",
"tag = field[0:3]\n",
"ind1 = field[3].replace('_', '')\n",
"ind2 = field[4].replace('_', '')\n",
"return tag, ind1, ind2\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"AugAssign'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_0(self, VAR_0):...\n",
"return VAR_0.id\n"
] | [
"def to_representation(self, obj):...\n",
"return obj.id\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_0():...\n",
"VAR_32 = hashlib.sha1()\n",
"VAR_32.update(uuid.uuid4().bytes)\n",
"VAR_33 = VAR_32.digest()\n",
"assert len(VAR_33) == ray_constants.ID_SIZE\n",
"return VAR_33\n"
] | [
"def _random_string():...\n",
"id_hash = hashlib.sha1()\n",
"id_hash.update(uuid.uuid4().bytes)\n",
"id_bytes = id_hash.digest()\n",
"assert len(id_bytes) == ray_constants.ID_SIZE\n",
"return id_bytes\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Assign'",
"Assert'",
"Return'"
] |
[
"def FUNC_7(self):...\n",
"\"\"\"docstring\"\"\"\n",
"self.subscribe(ray.gcs_utils.XRAY_HEARTBEAT_BATCH_CHANNEL)\n",
"self.subscribe(ray.gcs_utils.XRAY_DRIVER_CHANNEL)\n",
"while True:\n",
"self.update_local_scheduler_map()\n",
"if self.autoscaler:\n",
"self.autoscaler.update()\n",
"self._maybe_flush_gcs()\n",
"self.process_messages()\n",
"time.sleep(ray._config.heartbeat_timeout_milliseconds() * 0.001)\n"
] | [
"def run(self):...\n",
"\"\"\"docstring\"\"\"\n",
"self.subscribe(ray.gcs_utils.XRAY_HEARTBEAT_BATCH_CHANNEL)\n",
"self.subscribe(ray.gcs_utils.XRAY_DRIVER_CHANNEL)\n",
"while True:\n",
"self.update_local_scheduler_map()\n",
"if self.autoscaler:\n",
"self.autoscaler.update()\n",
"self._maybe_flush_gcs()\n",
"self.process_messages()\n",
"time.sleep(ray._config.heartbeat_timeout_milliseconds() * 0.001)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def __iter__(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return iter(self.parts)\n"
] | [
"def __iter__(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return iter(self.parts)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def FUNC_10(self, VAR_11, VAR_3):...\n",
"VAR_21 = set()\n",
"VAR_18 = VAR_11['rules']\n",
"for VAR_37 in VAR_18:\n",
"VAR_8 = VAR_3['rules'][VAR_37]\n",
"return VAR_21\n",
"VAR_21 |= FUNC_3(VAR_8, VAR_3)\n"
] | [
"def get_parameters(self, levelfields, doc):...\n",
"parameters = set()\n",
"rulenames = levelfields['rules']\n",
"for rulename in rulenames:\n",
"rule = doc['rules'][rulename]\n",
"return parameters\n",
"parameters |= get_rule_parameters(rule, doc)\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Return'",
"AugAssign'"
] |
[
"def FUNC_18():...\n",
"VAR_56 = constants.AUSTIN_URLS\n",
"VAR_57 = constants.SMASHBREWS_RULS\n",
"VAR_61 = constants.COLORADO_SINGLES_URLS\n",
"VAR_59 = constants.COLORADO_DOUBLES_URLS\n",
"VAR_60 = constants.SMS_URLS\n",
"VAR_20 = [['sms', VAR_60], ['smashbrews', VAR_57], ['austin', VAR_56], [\n 'colorado', VAR_61], ['colorado_doubles', VAR_59]]\n",
"return VAR_20\n"
] | [
"def get_list_of_named_scenes():...\n",
"austin = constants.AUSTIN_URLS\n",
"smashbrews = constants.SMASHBREWS_RULS\n",
"colorado_singles = constants.COLORADO_SINGLES_URLS\n",
"colorado_doubles = constants.COLORADO_DOUBLES_URLS\n",
"sms = constants.SMS_URLS\n",
"base_urls = [['sms', sms], ['smashbrews', smashbrews], ['austin', austin],\n ['colorado', colorado_singles], ['colorado_doubles', colorado_doubles]]\n",
"return base_urls\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"@utils.synchronized('3par', external=True)...\n",
""
] | [
"@utils.synchronized('3par', external=True)...\n",
""
] | [
0,
0
] | [
"Condition",
"Condition"
] |
[
"def FUNC_6(VAR_3):...\n",
"VAR_3.add_route('notes', '/notes', factory=NotesFactory)\n",
"VAR_3.add_route('new-note', '/notes/new')\n",
"VAR_3.add_route('note', pattern='/notes/{note}', traverse='/{note}',\n factory=NotesFactory)\n",
"VAR_3.add_route('note-action', '/api/notes')\n"
] | [
"def includeme(config):...\n",
"config.add_route('notes', '/notes', factory=NotesFactory)\n",
"config.add_route('new-note', '/notes/new')\n",
"config.add_route('note', pattern='/notes/{note}', traverse='/{note}',\n factory=NotesFactory)\n",
"config.add_route('note-action', '/api/notes')\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_16(self):...\n",
"return reverse('data_group_edit', VAR_4={'pk': self.pk})\n"
] | [
"def get_absolute_url(self):...\n",
"return reverse('data_group_edit', kwargs={'pk': self.pk})\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_0(VAR_0, VAR_1):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_3 = bs4.BeautifulSoup(VAR_0, 'html.parser')\n",
"VAR_4 = VAR_3.select('[name={}]'.format(VAR_1))\n",
"if not VAR_4:\n",
"print(\"Token '{}' not found in html text.\".format(VAR_1))\n",
"return VAR_4[0]['value']\n",
"return ''\n"
] | [
"def get_token(html, token_name):...\n",
"\"\"\"docstring\"\"\"\n",
"soup = bs4.BeautifulSoup(html, 'html.parser')\n",
"res = soup.select('[name={}]'.format(token_name))\n",
"if not res:\n",
"print(\"Token '{}' not found in html text.\".format(token_name))\n",
"return res[0]['value']\n",
"return ''\n"
] | [
0,
0,
0,
5,
0,
5,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Return'",
"Return'"
] |
[
"def FUNC_5(self):...\n",
"VAR_0 = {}\n",
"assert complex_column_expr(tuplify(['count', []]), VAR_0.copy()) == 'count()'\n",
"assert complex_column_expr(tuplify(['notEmpty', ['foo']]), VAR_0.copy()\n ) == 'notEmpty(foo)'\n",
"assert complex_column_expr(tuplify(['notEmpty', ['arrayElement', ['foo', 1]\n ]]), VAR_0.copy()) == 'notEmpty(arrayElement(foo, 1))'\n",
"assert complex_column_expr(tuplify(['foo', ['bar', ['qux'], 'baz']]), VAR_0\n .copy()) == 'foo(bar(qux), baz)'\n",
"assert complex_column_expr(tuplify(['foo', [], 'a']), VAR_0.copy()\n ) == '(foo() AS a)'\n",
"assert complex_column_expr(tuplify(['foo', ['b', 'c'], 'd']), VAR_0.copy()\n ) == '(foo(b, c) AS d)'\n",
"assert complex_column_expr(tuplify(['foo', ['b', 'c', ['d']]]), VAR_0.copy()\n ) == 'foo(b, c(d))'\n",
"assert complex_column_expr(tuplify(['topK', [3], ['project_id']]), VAR_0.copy()\n ) == 'topK(3)(project_id)'\n",
"assert complex_column_expr(tuplify(['topK', [3], ['project_id'], 'baz']),\n VAR_0.copy()) == '(topK(3)(project_id) AS baz)'\n",
"assert complex_column_expr(tuplify(['emptyIfNull', ['project_id']]), VAR_0.\n copy()) == \"ifNull(project_id, '')\"\n",
"assert complex_column_expr(tuplify(['emptyIfNull', ['project_id'], 'foo']),\n VAR_0.copy()) == \"(ifNull(project_id, '') AS foo)\"\n",
"assert complex_column_expr(tuplify(['positionCaseInsensitive', ['message',\n \"'lol 'single' quotes'\"]]), VAR_0.copy()\n ) == \"positionCaseInsensitive(message, 'lol \\\\'single\\\\' quotes')\"\n"
] | [
"def test_complex_conditions_expr(self):...\n",
"body = {}\n",
"assert complex_column_expr(tuplify(['count', []]), body.copy()) == 'count()'\n",
"assert complex_column_expr(tuplify(['notEmpty', ['foo']]), body.copy()\n ) == 'notEmpty(foo)'\n",
"assert complex_column_expr(tuplify(['notEmpty', ['arrayElement', ['foo', 1]\n ]]), body.copy()) == 'notEmpty(arrayElement(foo, 1))'\n",
"assert complex_column_expr(tuplify(['foo', ['bar', ['qux'], 'baz']]), body.\n copy()) == 'foo(bar(qux), baz)'\n",
"assert complex_column_expr(tuplify(['foo', [], 'a']), body.copy()\n ) == '(foo() AS a)'\n",
"assert complex_column_expr(tuplify(['foo', ['b', 'c'], 'd']), body.copy()\n ) == '(foo(b, c) AS d)'\n",
"assert complex_column_expr(tuplify(['foo', ['b', 'c', ['d']]]), body.copy()\n ) == 'foo(b, c(d))'\n",
"assert complex_column_expr(tuplify(['topK', [3], ['project_id']]), body.copy()\n ) == 'topK(3)(project_id)'\n",
"assert complex_column_expr(tuplify(['topK', [3], ['project_id'], 'baz']),\n body.copy()) == '(topK(3)(project_id) AS baz)'\n",
"assert complex_column_expr(tuplify(['emptyIfNull', ['project_id']]), body.\n copy()) == \"ifNull(project_id, '')\"\n",
"assert complex_column_expr(tuplify(['emptyIfNull', ['project_id'], 'foo']),\n body.copy()) == \"(ifNull(project_id, '') AS foo)\"\n",
"assert complex_column_expr(tuplify(['positionCaseInsensitive', ['message',\n \"'lol 'single' quotes'\"]]), body.copy()\n ) == \"positionCaseInsensitive(message, 'lol \\\\'single\\\\' quotes')\"\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'",
"Assert'"
] |
[
"def FUNC_14(self):...\n",
"VAR_4 = 'hubba-fooo'\n",
"VAR_13 = self.app.config['TOKEN_LOGIN_SHARED_KEY']\n",
"VAR_14 = '{:x}'.format(int(time.time()))\n",
"VAR_15 = os.urandom(16).encode('hex')\n",
"VAR_16 = sha256('{0}|{1}|{2}|{3}'.format(VAR_13, VAR_4, VAR_15, VAR_14)\n ).hexdigest()\n",
"VAR_17 = {'eppn': VAR_4, 'token': VAR_16, 'nonce': VAR_15, 'ts': VAR_14}\n",
"VAR_25 = c.post('/token-login', VAR_17=data)\n",
"self.assertEqual(VAR_25.status_code, 302)\n",
"self.assertTrue(VAR_25.location.startswith(self.app.config[\n 'TOKEN_LOGIN_SUCCESS_REDIRECT_URL']))\n"
] | [
"def test_token_login_new_user(self):...\n",
"eppn = 'hubba-fooo'\n",
"shared_key = self.app.config['TOKEN_LOGIN_SHARED_KEY']\n",
"timestamp = '{:x}'.format(int(time.time()))\n",
"nonce = os.urandom(16).encode('hex')\n",
"token = sha256('{0}|{1}|{2}|{3}'.format(shared_key, eppn, nonce, timestamp)\n ).hexdigest()\n",
"data = {'eppn': eppn, 'token': token, 'nonce': nonce, 'ts': timestamp}\n",
"resp = c.post('/token-login', data=data)\n",
"self.assertEqual(resp.status_code, 302)\n",
"self.assertTrue(resp.location.startswith(self.app.config[\n 'TOKEN_LOGIN_SUCCESS_REDIRECT_URL']))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_18(self):...\n",
"VAR_23 = 'my!pwd0#', 'some0therlong$pwd', 'pwd'\n",
"VAR_24 = {'name_pwd': 'name1', 'password': VAR_23[0], 'some_list': {\n 'name_password': 'name2', 'password': VAR_23[1]}, 'password': VAR_23[2]}\n",
"VAR_25 = client.RESTClient(None)\n",
"VAR_26 = jsonutils.dumps(VAR_24)\n",
"VAR_27 = VAR_25._mask_password(VAR_26)\n",
"for pwd in VAR_23:\n",
"VAR_26 = VAR_26.replace('\"' + pwd + '\"', '\"********\"')\n",
"self.assertEqual(VAR_26, VAR_27)\n"
] | [
"def test_mask_password(self):...\n",
"pwds = 'my!pwd0#', 'some0therlong$pwd', 'pwd'\n",
"body = {'name_pwd': 'name1', 'password': pwds[0], 'some_list': {\n 'name_password': 'name2', 'password': pwds[1]}, 'password': pwds[2]}\n",
"cl = client.RESTClient(None)\n",
"json_body = jsonutils.dumps(body)\n",
"masked_body = cl._mask_password(json_body)\n",
"for pwd in pwds:\n",
"json_body = json_body.replace('\"' + pwd + '\"', '\"********\"')\n",
"self.assertEqual(json_body, masked_body)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Expr'"
] |
[
"def FUNC_14(self, VAR_14):...\n",
""
] | [
"def is_boolean(self, col_name):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"async def FUNC_1(self, VAR_1: str='') ->None:...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_4 = utility.list_languages()\n",
"if not VAR_1:\n",
"VAR_1 = 'text'\n",
"if VAR_1 not in VAR_4:\n",
"VAR_0.debug('CreatePaste.get: non-existent logger requested')\n",
"await self.render('new.html', VAR_1=lexer, VAR_4=lexers, pagetitle='new',\n message=None)\n",
"self.set_status(404)\n",
"self.render('404.html', pagetitle='404')\n",
"return\n"
] | [
"async def get(self, lexer: str='') ->None:...\n",
"\"\"\"docstring\"\"\"\n",
"lexers = utility.list_languages()\n",
"if not lexer:\n",
"lexer = 'text'\n",
"if lexer not in lexers:\n",
"log.debug('CreatePaste.get: non-existent logger requested')\n",
"await self.render('new.html', lexer=lexer, lexers=lexers, pagetitle='new',\n message=None)\n",
"self.set_status(404)\n",
"self.render('404.html', pagetitle='404')\n",
"return\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"AsyncFunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Return'"
] |
[
"@app.route('/api/sequences/<id>/start', methods=['POST'])...\n",
"controller.sequences_runner.run(VAR_4)\n",
"return controller.sequences.lookup(VAR_4).to_map()\n"
] | [
"@app.route('/api/sequences/<id>/start', methods=['POST'])...\n",
"controller.sequences_runner.run(id)\n",
"return controller.sequences.lookup(id).to_map()\n"
] | [
0,
0,
0
] | [
"Condition",
"Expr'",
"Return'"
] |
[
"def FUNC_22(VAR_10, VAR_3, VAR_12=False):...\n",
"if not VAR_12:\n",
"VAR_12 = CFG('default_token_count')\n",
"VAR_29 = [FUNC_21() for x in range(0, VAR_12)]\n",
"for VAR_4 in VAR_29:\n",
"VAR_32 = VAR_3\n",
"return VAR_29\n",
"VAR_35 = 'NONE'\n",
"VAR_28 = VAR_4, VAR_32, VAR_35\n",
"VAR_18 = 'INSERT INTO {} VALUES (?, ?, ?)'.format(CFG('tokens_table_name'))\n",
"VAR_10.execute(VAR_18, VAR_28)\n"
] | [
"def genTokens(c, poll_name, count=False):...\n",
"if not count:\n",
"count = CFG('default_token_count')\n",
"tokens = [genSingleToken() for x in range(0, count)]\n",
"for token in tokens:\n",
"name = poll_name\n",
"return tokens\n",
"options_selected = 'NONE'\n",
"params = token, name, options_selected\n",
"req = 'INSERT INTO {} VALUES (?, ?, ?)'.format(CFG('tokens_table_name'))\n",
"c.execute(req, params)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Assign'",
"For",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"\"\"\"\nModule contains classes for returning errata data from DB\n\"\"\"\n",
"\"\"\"\n Class to hold Erratum attributes\n \"\"\"\n",
"def __init__(self, VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5, VAR_6, VAR_7):...\n",
"setattr(self, 'name', VAR_1)\n",
"setattr(self, 'id', VAR_0)\n",
"VAR_17 = {}\n",
"VAR_17['type'] = None\n",
"VAR_17['issued'] = str(VAR_6)\n",
"VAR_17['synopsis'] = VAR_2\n",
"VAR_17['description'] = VAR_4\n",
"VAR_17['solution'] = VAR_5\n",
"VAR_17['severity'] = VAR_3\n",
"VAR_17['summary'] = None\n",
"VAR_17['updated'] = str(VAR_7)\n",
"VAR_17['url'] = 'https://access.redhat.com/errata/%s' % VAR_1\n",
"VAR_17['bugzilla_list'] = []\n",
"VAR_17['cve_list'] = []\n",
"VAR_17['package_list'] = []\n",
"VAR_17['reference_list'] = []\n",
"setattr(self, 'mydict', VAR_17)\n",
"def FUNC_0(self, VAR_8):...\n",
"VAR_17 = self.get_val('mydict')\n",
"VAR_17['cve_list'] = VAR_8\n",
"def FUNC_1(self, VAR_9):...\n",
"VAR_17 = self.get_val('mydict')\n",
"VAR_17['package_list'] = VAR_9\n",
"def FUNC_2(self, VAR_10):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_18 = None\n",
"if VAR_10 in vars(self):\n",
"VAR_18 = getattr(self, VAR_10)\n",
"return VAR_18\n"
] | [
"\"\"\"\nModule contains classes for returning errata data from DB\n\"\"\"\n",
"\"\"\"\n Class to hold Erratum attributes\n \"\"\"\n",
"def __init__(self, id, name, synopsis, severity, description, solution,...\n",
"setattr(self, 'name', name)\n",
"setattr(self, 'id', id)\n",
"mydict = {}\n",
"mydict['type'] = None\n",
"mydict['issued'] = str(issued)\n",
"mydict['synopsis'] = synopsis\n",
"mydict['description'] = description\n",
"mydict['solution'] = solution\n",
"mydict['severity'] = severity\n",
"mydict['summary'] = None\n",
"mydict['updated'] = str(updated)\n",
"mydict['url'] = 'https://access.redhat.com/errata/%s' % name\n",
"mydict['bugzilla_list'] = []\n",
"mydict['cve_list'] = []\n",
"mydict['package_list'] = []\n",
"mydict['reference_list'] = []\n",
"setattr(self, 'mydict', mydict)\n",
"def set_cve_names(self, cve_name_list):...\n",
"mydict = self.get_val('mydict')\n",
"mydict['cve_list'] = cve_name_list\n",
"def set_packages(self, package_list):...\n",
"mydict = self.get_val('mydict')\n",
"mydict['package_list'] = package_list\n",
"def get_val(self, attr_name):...\n",
"\"\"\"docstring\"\"\"\n",
"value = None\n",
"if attr_name in vars(self):\n",
"value = getattr(self, attr_name)\n",
"return value\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"Expr'",
"FunctionDef'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"FunctionDef'",
"Assign'",
"Assign'",
"FunctionDef'",
"Assign'",
"Assign'",
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Return'"
] |
[
"def FUNC_0(self):...\n",
"return self.get_secure_cookie('user')\n"
] | [
"def get_current_user(self):...\n",
"return self.get_secure_cookie('user')\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_25(self):...\n",
"return self._picture\n"
] | [
"def picture(self):...\n",
"return self._picture\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_6(self, VAR_8):...\n",
"VAR_14 = (\n \"UPDATE `testdb`.`report` SET `Is_Resolved` = '1' WHERE `report`.`Report_ID` = \"\n + VAR_8)\n",
"self.cursor.execute(VAR_14)\n",
"self.connection.commit()\n"
] | [
"def resolve_issue(self, reportID):...\n",
"query = (\n \"UPDATE `testdb`.`report` SET `Is_Resolved` = '1' WHERE `report`.`Report_ID` = \"\n + reportID)\n",
"self.cursor.execute(query)\n",
"self.connection.commit()\n"
] | [
0,
4,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_3(self, VAR_15, VAR_16):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_20 = gcp.GceContractBuilder(self.gce_observer)\n",
"VAR_22 = VAR_20.new_clause_builder('Instances Deleted', retryable_for_secs=\n 15, strict=True).list_resources('instances')\n",
"for name in VAR_15:\n",
"VAR_40 = jc.PathContainsPredicate('name', name)\n",
"VAR_21 = self.agent.type_to_payload('terminateInstances', {'instanceIds':\n VAR_15, 'zone': VAR_16, 'credentials': self.bindings['GCE_CREDENTIALS']})\n",
"VAR_41 = jc.PathEqPredicate('status', 'STOPPING')\n",
"return st.OperationContract(self.new_post_operation(title=\n 'terminate_instances', data=payload, VAR_29='gce/ops'), contract=\n builder.build())\n",
"VAR_22.add_mapped_constraint(jc.IF(VAR_40, VAR_41))\n"
] | [
"def terminate_instances(self, names, zone):...\n",
"\"\"\"docstring\"\"\"\n",
"builder = gcp.GceContractBuilder(self.gce_observer)\n",
"clause = builder.new_clause_builder('Instances Deleted', retryable_for_secs\n =15, strict=True).list_resources('instances')\n",
"for name in names:\n",
"name_matches_pred = jc.PathContainsPredicate('name', name)\n",
"payload = self.agent.type_to_payload('terminateInstances', {'instanceIds':\n names, 'zone': zone, 'credentials': self.bindings['GCE_CREDENTIALS']})\n",
"is_stopping_pred = jc.PathEqPredicate('status', 'STOPPING')\n",
"return st.OperationContract(self.new_post_operation(title=\n 'terminate_instances', data=payload, path='gce/ops'), contract=builder.\n build())\n",
"clause.add_mapped_constraint(jc.IF(name_matches_pred, is_stopping_pred))\n"
] | [
0,
0,
0,
0,
0,
1,
0,
1,
0,
1
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"For",
"Assign'",
"Assign'",
"Assign'",
"Return'",
"Expr'"
] |
[
"def __init__(self, VAR_0, VAR_1, VAR_2):...\n",
"super(CLASS_3, self).__init__(VAR_0, VAR_1, VAR_2, 'POST')\n"
] | [
"def __init__(self, connection, args, logger):...\n",
"super(HttpPost, self).__init__(connection, args, logger, 'POST')\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_8():...\n",
"VAR_38 = FUNC_3(VAR_18, VAR_19)\n",
"VAR_37 = CLASS_19 if VAR_20 else CLASS_20\n",
"return VAR_37, VAR_38\n"
] | [
"def five():...\n",
"HHFormSet = make_formset(parent, child)\n",
"ParentForm = ExtractedHHDocForm if extracted else ExtractedHHDocEditForm\n",
"return ParentForm, HHFormSet\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_45(self):...\n",
"return [i.name for i in self.obj.__mapper__.columns if isinstance(i.type,\n ImageColumn)]\n"
] | [
"def get_image_column_list(self):...\n",
"return [i.name for i in self.obj.__mapper__.columns if isinstance(i.type,\n ImageColumn)]\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_4(VAR_5, VAR_7):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_5.execute(\n f\"\"\"string{VAR_7['title']}\",\n \"{VAR_7.get('description', '')}\"\n )\n \"\"\"\n )\n",
"VAR_11 = VAR_5.lastrowid\n",
"for tag in VAR_7.get('tags', []):\n",
"VAR_5.execute(\n f\"\"\"string{tag.get('namespace', '')}\",\n \"{tag.get('predicate', '')}\",\n \"{tag.get('value', '')}\",\n \"{VAR_11}\"\n )\n \"\"\"\n )\n",
"return VAR_11\n"
] | [
"def create_issue(cursor, issue):...\n",
"\"\"\"docstring\"\"\"\n",
"cursor.execute(\n f\"\"\"\n INSERT INTO issue (\n title,\n description\n )\n VALUES (\n \"{issue['title']}\",\n \"{issue.get('description', '')}\"\n )\n \"\"\"\n )\n",
"issue_id = cursor.lastrowid\n",
"for tag in issue.get('tags', []):\n",
"cursor.execute(\n f\"\"\"\n INSERT INTO tag (\n namespace,\n predicate,\n value,\n issue_id\n )\n VALUES (\n \"{tag.get('namespace', '')}\",\n \"{tag.get('predicate', '')}\",\n \"{tag.get('value', '')}\",\n \"{issue_id}\"\n )\n \"\"\"\n )\n",
"return issue_id\n"
] | [
0,
0,
4,
0,
0,
4,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Assign'",
"For",
"Expr'",
"Return'"
] |
[
"def FUNC_0(self):...\n",
"VAR_1 = 'sh'\n",
"self.assertEqual(escape_path_argument('/home/usr/a-file', VAR_1),\n '/home/usr/a-file')\n",
"self.assertEqual(escape_path_argument('/home/usr/a-dir/', VAR_1),\n '/home/usr/a-dir/')\n",
"self.assertEqual(escape_path_argument('/home/us r/a-file with spaces.bla',\n VAR_1), '/home/us\\\\ r/a-file\\\\ with\\\\ spaces.bla')\n",
"self.assertEqual(escape_path_argument('/home/us r/a-dir with spaces/x/',\n VAR_1), '/home/us\\\\ r/a-dir\\\\ with\\\\ spaces/x/')\n",
"self.assertEqual(escape_path_argument(\n 'relative something/with cherries and/pickles.delicious', VAR_1),\n 'relative\\\\ something/with\\\\ cherries\\\\ and/pickles.delicious')\n"
] | [
"def test_escape_path_argument_sh(self):...\n",
"_type = 'sh'\n",
"self.assertEqual(escape_path_argument('/home/usr/a-file', _type),\n '/home/usr/a-file')\n",
"self.assertEqual(escape_path_argument('/home/usr/a-dir/', _type),\n '/home/usr/a-dir/')\n",
"self.assertEqual(escape_path_argument('/home/us r/a-file with spaces.bla',\n _type), '/home/us\\\\ r/a-file\\\\ with\\\\ spaces.bla')\n",
"self.assertEqual(escape_path_argument('/home/us r/a-dir with spaces/x/',\n _type), '/home/us\\\\ r/a-dir\\\\ with\\\\ spaces/x/')\n",
"self.assertEqual(escape_path_argument(\n 'relative something/with cherries and/pickles.delicious', _type),\n 'relative\\\\ something/with\\\\ cherries\\\\ and/pickles.delicious')\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_10(VAR_7, VAR_10, VAR_11):...\n",
"if VAR_7 not in VAR_10.keys():\n",
"if VAR_11:\n",
"print(VAR_10[VAR_7])\n",
"print('The syscall number for {0} is: {1} (0x{1:X})'.format(VAR_7, VAR_10[\n VAR_7]))\n"
] | [
"def print_single_syscall(syscall_name, syscalls, quiet):...\n",
"if syscall_name not in syscalls.keys():\n",
"if quiet:\n",
"print(syscalls[syscall_name])\n",
"print('The syscall number for {0} is: {1} (0x{1:X})'.format(syscall_name,\n syscalls[syscall_name]))\n"
] | [
0,
2,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_7(self):...\n",
"VAR_1 = '/api/apps'\n",
"VAR_2 = self.client.post(VAR_1)\n",
"self.assertEqual(VAR_2.status_code, 201)\n",
"VAR_3 = VAR_2.data['id']\n",
"VAR_1 = '/api/apps/{app_id}/builds'.format(**locals())\n",
"VAR_4 = {'image': 'autotest/example', 'sha': 'a' * 40, 'procfile': json.\n dumps({'web': 'node server.js', 'worker': 'node worker.js'})}\n",
"VAR_2 = self.client.post(VAR_1, json.dumps(VAR_4), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_2.status_code, 201)\n",
"VAR_1 = '/api/apps/{app_id}/builds'.format(**locals())\n",
"VAR_2 = self.client.get(VAR_1)\n",
"self.assertEqual(VAR_2.status_code, 200)\n",
"self.assertEqual(len(VAR_2.data['results']), 2)\n",
"VAR_1 = '/api/apps/{app_id}/releases'.format(**locals())\n",
"VAR_2 = self.client.get(VAR_1)\n",
"self.assertEqual(VAR_2.status_code, 200)\n",
"self.assertEqual(len(VAR_2.data['results']), 2)\n",
"VAR_1 = '/api/apps/{app_id}/containers'.format(**locals())\n",
"VAR_2 = self.client.get(VAR_1)\n",
"self.assertEqual(VAR_2.status_code, 200)\n",
"self.assertEqual(len(VAR_2.data['results']), 1)\n",
"chaos.CREATE_ERROR_RATE = 1\n",
"VAR_1 = '/api/apps/{app_id}/run'.format(**locals())\n",
"VAR_4 = {'command': 'ls -al'}\n",
"VAR_2 = self.client.post(VAR_1, json.dumps(VAR_4), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_2.status_code, 503)\n"
] | [
"def test_run_chaos(self):...\n",
"url = '/api/apps'\n",
"response = self.client.post(url)\n",
"self.assertEqual(response.status_code, 201)\n",
"app_id = response.data['id']\n",
"url = '/api/apps/{app_id}/builds'.format(**locals())\n",
"body = {'image': 'autotest/example', 'sha': 'a' * 40, 'procfile': json.\n dumps({'web': 'node server.js', 'worker': 'node worker.js'})}\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 201)\n",
"url = '/api/apps/{app_id}/builds'.format(**locals())\n",
"response = self.client.get(url)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertEqual(len(response.data['results']), 2)\n",
"url = '/api/apps/{app_id}/releases'.format(**locals())\n",
"response = self.client.get(url)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertEqual(len(response.data['results']), 2)\n",
"url = '/api/apps/{app_id}/containers'.format(**locals())\n",
"response = self.client.get(url)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertEqual(len(response.data['results']), 1)\n",
"chaos.CREATE_ERROR_RATE = 1\n",
"url = '/api/apps/{app_id}/run'.format(**locals())\n",
"body = {'command': 'ls -al'}\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 503)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_6(self, VAR_13):...\n",
"if VAR_13:\n",
"VAR_13 = VAR_100(VAR_13.split('[')[1].strip(']'))\n",
"return 'en'\n",
"if VAR_13 in g.all_languages:\n",
"return VAR_13\n"
] | [
"def run(self, lang):...\n",
"if lang:\n",
"lang = str(lang.split('[')[1].strip(']'))\n",
"return 'en'\n",
"if lang in g.all_languages:\n",
"return lang\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Return'",
"Condition",
"Return'"
] |
[
"import unittest\n",
"import odin\n",
"from odin import traversal\n",
"VAR_7 = 'odin.traversal'\n",
"VAR_2 = odin.StringField()\n",
"VAR_7 = 'odin.traversal'\n",
"VAR_2 = odin.StringField()\n",
"VAR_3 = odin.ListOf(CLASS_0)\n",
"VAR_7 = 'odin.traversal'\n",
"VAR_2 = odin.StringField()\n",
"VAR_4 = odin.DictAs(CLASS_1)\n",
"VAR_5 = odin.DictOf(CLASS_1)\n",
"VAR_0 = CLASS_2(VAR_2='a', VAR_4=Level2(name='b', level3s=[]), VAR_5=dict(a\n =Level2(name='c', level3s=[]), b=Level2(name='d', level3s=[Level3(name=\n 'e'), Level3(name='f')]), c=Level2(name='g', level3s=[Level3(name='h')])))\n",
"VAR_1 = [CLASS_2(VAR_2='a', VAR_4=Level2(name='b', level3s=[]), VAR_5=dict(\n a=Level2(name='c', level3s=[]), b=Level2(name='d', level3s=[Level3(name\n ='e'), Level3(name='f')]), c=Level2(name='g', level3s=[Level3(name='h')\n ]))), CLASS_2(VAR_2='i', VAR_4=Level2(name='j', level3s=[]), VAR_5=dict\n (a=Level2(name='k', level3s=[]), b=Level2(name='l', level3s=[Level3(\n name='m'), Level3(name='n')]), c=Level2(name='o', level3s=[Level3(name=\n 'p')])))]\n",
"def __init__(self, VAR_6):...\n",
"super(CLASS_3, self).__init__(VAR_6)\n",
"self.events = []\n",
"def FUNC_0(self):...\n",
"self.events.append('on_pre_enter: %s' % self.path)\n",
"def FUNC_1(self):...\n",
"self.events.append('on_enter: %s' % self.path)\n",
"def FUNC_2(self):...\n",
"self.events.append('on_exit: %s' % self.path)\n",
"def FUNC_3(self):...\n",
"VAR_0.full_clean()\n",
"VAR_8 = CLASS_3(VAR_0)\n",
"VAR_9 = [('%s %s %s' % (VAR_11, VAR_11.name, VAR_8.depth)) for VAR_11 in VAR_8]\n",
"self.assertListEqual(['on_enter: ', 'on_enter: level2', 'on_exit: level2',\n 'on_enter: level2s[a]', 'on_exit: level2s[a]', 'on_enter: level2s[b]',\n 'on_enter: level2s[b].level3s[0]', 'on_exit: level2s[b].level3s[0]',\n 'on_enter: level2s[b].level3s[1]', 'on_exit: level2s[b].level3s[1]',\n 'on_exit: level2s[b]', 'on_enter: level2s[c]',\n 'on_enter: level2s[c].level3s[0]', 'on_exit: level2s[c].level3s[0]',\n 'on_exit: level2s[c]', 'on_exit: '], VAR_8.events)\n",
"self.assertListEqual(['odin.traversal.Level1 resource a 0',\n 'odin.traversal.Level2 resource b 1',\n 'odin.traversal.Level2 resource c 1',\n 'odin.traversal.Level2 resource d 1',\n 'odin.traversal.Level3 resource e 2',\n 'odin.traversal.Level3 resource f 2',\n 'odin.traversal.Level2 resource g 1',\n 'odin.traversal.Level3 resource h 2'], VAR_9)\n",
"def FUNC_4(self):...\n",
"VAR_0.full_clean()\n",
"VAR_8 = CLASS_3(VAR_1)\n",
"VAR_9 = [('%s %s %s' % (VAR_11, VAR_11.name, VAR_8.depth)) for VAR_11 in VAR_8]\n",
"self.assertListEqual(['on_enter: ', 'on_enter: level2', 'on_exit: level2',\n 'on_enter: level2s[a]', 'on_exit: level2s[a]', 'on_enter: level2s[b]',\n 'on_enter: level2s[b].level3s[0]', 'on_exit: level2s[b].level3s[0]',\n 'on_enter: level2s[b].level3s[1]', 'on_exit: level2s[b].level3s[1]',\n 'on_exit: level2s[b]', 'on_enter: level2s[c]',\n 'on_enter: level2s[c].level3s[0]', 'on_exit: level2s[c].level3s[0]',\n 'on_exit: level2s[c]', 'on_exit: ', 'on_enter: ', 'on_enter: level2',\n 'on_exit: level2', 'on_enter: level2s[a]', 'on_exit: level2s[a]',\n 'on_enter: level2s[b]', 'on_enter: level2s[b].level3s[0]',\n 'on_exit: level2s[b].level3s[0]', 'on_enter: level2s[b].level3s[1]',\n 'on_exit: level2s[b].level3s[1]', 'on_exit: level2s[b]',\n 'on_enter: level2s[c]', 'on_enter: level2s[c].level3s[0]',\n 'on_exit: level2s[c].level3s[0]', 'on_exit: level2s[c]', 'on_exit: '],\n VAR_8.events)\n",
"self.assertListEqual(['odin.traversal.Level1 resource a 0',\n 'odin.traversal.Level2 resource b 1',\n 'odin.traversal.Level2 resource c 1',\n 'odin.traversal.Level2 resource d 1',\n 'odin.traversal.Level3 resource e 2',\n 'odin.traversal.Level3 resource f 2',\n 'odin.traversal.Level2 resource g 1',\n 'odin.traversal.Level3 resource h 2',\n 'odin.traversal.Level1 resource i 0',\n 'odin.traversal.Level2 resource j 1',\n 'odin.traversal.Level2 resource k 1',\n 'odin.traversal.Level2 resource l 1',\n 'odin.traversal.Level3 resource m 2',\n 'odin.traversal.Level3 resource n 2',\n 'odin.traversal.Level2 resource o 1',\n 'odin.traversal.Level3 resource p 2'], VAR_9)\n",
"def FUNC_5(self):...\n",
"VAR_10 = traversal.TraversalPath.parse('level2')\n",
"self.assertEqual(traversal.TraversalPath((traversal.NotSupplied, traversal.\n NotSupplied, 'level2')), VAR_10)\n",
"VAR_10 = traversal.TraversalPath.parse('level2.name')\n",
"self.assertEqual(traversal.TraversalPath((traversal.NotSupplied, traversal.\n NotSupplied, 'level2'), (traversal.NotSupplied, traversal.NotSupplied,\n 'name')), VAR_10)\n",
"VAR_10 = traversal.TraversalPath.parse('level2s[b].level3s[1].name')\n",
"self.assertEqual(traversal.TraversalPath(('b', traversal.NotSupplied,\n 'level2s'), ('1', traversal.NotSupplied, 'level3s'), (traversal.\n NotSupplied, traversal.NotSupplied, 'name')), VAR_10)\n",
"VAR_10 = traversal.TraversalPath.parse('level2s[b].level3s{code=abc}.name')\n",
"self.assertEqual(traversal.TraversalPath(('b', traversal.NotSupplied,\n 'level2s'), ('abc', 'code', 'level3s'), (traversal.NotSupplied,\n traversal.NotSupplied, 'name')), VAR_10)\n",
"def FUNC_6(self):...\n",
"VAR_10 = traversal.TraversalPath.parse('level2') + 'name'\n",
"self.assertEqual(traversal.TraversalPath.parse('level2.name'), VAR_10)\n",
"VAR_10 = traversal.TraversalPath.parse('level2s[b]'\n ) + traversal.TraversalPath.parse('level3s[1].name')\n",
"self.assertEqual(traversal.TraversalPath.parse('level2s[b].level3s[1].name'\n ), VAR_10)\n",
"def FUNC_7(self):...\n",
"self.assertEqual('a', traversal.TraversalPath.parse('name').get_value(VAR_0))\n",
"self.assertEqual('b', traversal.TraversalPath.parse('level2.name').\n get_value(VAR_0))\n",
"VAR_11 = traversal.TraversalPath.parse('level2s[b].level3s[1]').get_value(VAR_0\n )\n",
"self.assertIsInstance(VAR_11, CLASS_0)\n",
"self.assertEqual('f', VAR_11.name)\n",
"def FUNC_8(self):...\n",
"VAR_12 = traversal.TraversalPath.parse('level2s[b].level3s[4]')\n",
"self.assertRaises(IndexError, VAR_12.get_value, VAR_0)\n",
"VAR_12 = traversal.TraversalPath.parse('level2s[b].level3s_sd[1]')\n",
"self.assertRaises(KeyError, VAR_12.get_value, VAR_0)\n"
] | [
"import unittest\n",
"import odin\n",
"from odin import traversal\n",
"namespace = 'odin.traversal'\n",
"name = odin.StringField()\n",
"namespace = 'odin.traversal'\n",
"name = odin.StringField()\n",
"level3s = odin.ListOf(Level3)\n",
"namespace = 'odin.traversal'\n",
"name = odin.StringField()\n",
"level2 = odin.DictAs(Level2)\n",
"level2s = odin.DictOf(Level2)\n",
"TEST_STRUCTURE = Level1(name='a', level2=Level2(name='b', level3s=[]),\n level2s=dict(a=Level2(name='c', level3s=[]), b=Level2(name='d', level3s\n =[Level3(name='e'), Level3(name='f')]), c=Level2(name='g', level3s=[\n Level3(name='h')])))\n",
"TEST_LIST_STRUCTURE = [Level1(name='a', level2=Level2(name='b', level3s=[]),\n level2s=dict(a=Level2(name='c', level3s=[]), b=Level2(name='d', level3s\n =[Level3(name='e'), Level3(name='f')]), c=Level2(name='g', level3s=[\n Level3(name='h')]))), Level1(name='i', level2=Level2(name='j', level3s=\n []), level2s=dict(a=Level2(name='k', level3s=[]), b=Level2(name='l',\n level3s=[Level3(name='m'), Level3(name='n')]), c=Level2(name='o',\n level3s=[Level3(name='p')])))]\n",
"def __init__(self, resource):...\n",
"super(TestResourceTraversalIterator, self).__init__(resource)\n",
"self.events = []\n",
"def on_pre_enter(self):...\n",
"self.events.append('on_pre_enter: %s' % self.path)\n",
"def on_enter(self):...\n",
"self.events.append('on_enter: %s' % self.path)\n",
"def on_exit(self):...\n",
"self.events.append('on_exit: %s' % self.path)\n",
"def test_structure(self):...\n",
"TEST_STRUCTURE.full_clean()\n",
"resource_iter = TestResourceTraversalIterator(TEST_STRUCTURE)\n",
"resources = [('%s %s %s' % (r, r.name, resource_iter.depth)) for r in\n resource_iter]\n",
"self.assertListEqual(['on_enter: ', 'on_enter: level2', 'on_exit: level2',\n 'on_enter: level2s[a]', 'on_exit: level2s[a]', 'on_enter: level2s[b]',\n 'on_enter: level2s[b].level3s[0]', 'on_exit: level2s[b].level3s[0]',\n 'on_enter: level2s[b].level3s[1]', 'on_exit: level2s[b].level3s[1]',\n 'on_exit: level2s[b]', 'on_enter: level2s[c]',\n 'on_enter: level2s[c].level3s[0]', 'on_exit: level2s[c].level3s[0]',\n 'on_exit: level2s[c]', 'on_exit: '], resource_iter.events)\n",
"self.assertListEqual(['odin.traversal.Level1 resource a 0',\n 'odin.traversal.Level2 resource b 1',\n 'odin.traversal.Level2 resource c 1',\n 'odin.traversal.Level2 resource d 1',\n 'odin.traversal.Level3 resource e 2',\n 'odin.traversal.Level3 resource f 2',\n 'odin.traversal.Level2 resource g 1',\n 'odin.traversal.Level3 resource h 2'], resources)\n",
"def test_list_structure(self):...\n",
"TEST_STRUCTURE.full_clean()\n",
"resource_iter = TestResourceTraversalIterator(TEST_LIST_STRUCTURE)\n",
"resources = [('%s %s %s' % (r, r.name, resource_iter.depth)) for r in\n resource_iter]\n",
"self.assertListEqual(['on_enter: ', 'on_enter: level2', 'on_exit: level2',\n 'on_enter: level2s[a]', 'on_exit: level2s[a]', 'on_enter: level2s[b]',\n 'on_enter: level2s[b].level3s[0]', 'on_exit: level2s[b].level3s[0]',\n 'on_enter: level2s[b].level3s[1]', 'on_exit: level2s[b].level3s[1]',\n 'on_exit: level2s[b]', 'on_enter: level2s[c]',\n 'on_enter: level2s[c].level3s[0]', 'on_exit: level2s[c].level3s[0]',\n 'on_exit: level2s[c]', 'on_exit: ', 'on_enter: ', 'on_enter: level2',\n 'on_exit: level2', 'on_enter: level2s[a]', 'on_exit: level2s[a]',\n 'on_enter: level2s[b]', 'on_enter: level2s[b].level3s[0]',\n 'on_exit: level2s[b].level3s[0]', 'on_enter: level2s[b].level3s[1]',\n 'on_exit: level2s[b].level3s[1]', 'on_exit: level2s[b]',\n 'on_enter: level2s[c]', 'on_enter: level2s[c].level3s[0]',\n 'on_exit: level2s[c].level3s[0]', 'on_exit: level2s[c]', 'on_exit: '],\n resource_iter.events)\n",
"self.assertListEqual(['odin.traversal.Level1 resource a 0',\n 'odin.traversal.Level2 resource b 1',\n 'odin.traversal.Level2 resource c 1',\n 'odin.traversal.Level2 resource d 1',\n 'odin.traversal.Level3 resource e 2',\n 'odin.traversal.Level3 resource f 2',\n 'odin.traversal.Level2 resource g 1',\n 'odin.traversal.Level3 resource h 2',\n 'odin.traversal.Level1 resource i 0',\n 'odin.traversal.Level2 resource j 1',\n 'odin.traversal.Level2 resource k 1',\n 'odin.traversal.Level2 resource l 1',\n 'odin.traversal.Level3 resource m 2',\n 'odin.traversal.Level3 resource n 2',\n 'odin.traversal.Level2 resource o 1',\n 'odin.traversal.Level3 resource p 2'], resources)\n",
"def test_parse(self):...\n",
"actual = traversal.TraversalPath.parse('level2')\n",
"self.assertEqual(traversal.TraversalPath((traversal.NotSupplied, traversal.\n NotSupplied, 'level2')), actual)\n",
"actual = traversal.TraversalPath.parse('level2.name')\n",
"self.assertEqual(traversal.TraversalPath((traversal.NotSupplied, traversal.\n NotSupplied, 'level2'), (traversal.NotSupplied, traversal.NotSupplied,\n 'name')), actual)\n",
"actual = traversal.TraversalPath.parse('level2s[b].level3s[1].name')\n",
"self.assertEqual(traversal.TraversalPath(('b', traversal.NotSupplied,\n 'level2s'), ('1', traversal.NotSupplied, 'level3s'), (traversal.\n NotSupplied, traversal.NotSupplied, 'name')), actual)\n",
"actual = traversal.TraversalPath.parse('level2s[b].level3s{code=abc}.name')\n",
"self.assertEqual(traversal.TraversalPath(('b', traversal.NotSupplied,\n 'level2s'), ('abc', 'code', 'level3s'), (traversal.NotSupplied,\n traversal.NotSupplied, 'name')), actual)\n",
"def test_add(self):...\n",
"actual = traversal.TraversalPath.parse('level2') + 'name'\n",
"self.assertEqual(traversal.TraversalPath.parse('level2.name'), actual)\n",
"actual = traversal.TraversalPath.parse('level2s[b]'\n ) + traversal.TraversalPath.parse('level3s[1].name')\n",
"self.assertEqual(traversal.TraversalPath.parse('level2s[b].level3s[1].name'\n ), actual)\n",
"def test_valid_path(self):...\n",
"self.assertEqual('a', traversal.TraversalPath.parse('name').get_value(\n TEST_STRUCTURE))\n",
"self.assertEqual('b', traversal.TraversalPath.parse('level2.name').\n get_value(TEST_STRUCTURE))\n",
"r = traversal.TraversalPath.parse('level2s[b].level3s[1]').get_value(\n TEST_STRUCTURE)\n",
"self.assertIsInstance(r, Level3)\n",
"self.assertEqual('f', r.name)\n",
"def test_invalid_path(self):...\n",
"path = traversal.TraversalPath.parse('level2s[b].level3s[4]')\n",
"self.assertRaises(IndexError, path.get_value, TEST_STRUCTURE)\n",
"path = traversal.TraversalPath.parse('level2s[b].level3s_sd[1]')\n",
"self.assertRaises(KeyError, path.get_value, TEST_STRUCTURE)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Import'",
"Import'",
"ImportFrom'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"FunctionDef'",
"Expr'",
"Assign'",
"FunctionDef'",
"Expr'",
"FunctionDef'",
"Expr'",
"FunctionDef'",
"Expr'",
"FunctionDef'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"FunctionDef'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"FunctionDef'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"FunctionDef'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"FunctionDef'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"FunctionDef'",
"Assign'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"def FUNC_1():...\n",
"print(\"Starting script... press 'ctrl+c' in terminal to turn off\")\n",
"while True:\n",
"if pyperclip.paste() != VAR_1 and len(pyperclip.paste().split()) < 5:\n",
"VAR_1 = pyperclip.paste()\n",
"VAR_4 = False\n",
"VAR_5 = requests.get('https://api-portal.dictionary.com/dcom/pageData/%s' %\n VAR_1)\n",
"VAR_6 = False\n",
"VAR_7 = requests.get('https://api.urbandictionary.com/v0/define?term=%s' %\n VAR_1)\n",
"VAR_8 = json.loads(VAR_5.text)['data']['content'][0]['entries'][0]['posBlocks'\n ][0]['definitions']\n",
"os.system('notify-send \"Cant find |%s| on dictionary.com!\"' % VAR_1)\n",
"if not VAR_4:\n",
"VAR_4 = True\n",
"VAR_9 = []\n",
"VAR_10 = json.loads(VAR_7.text)['list']\n",
"os.system('notify-send \"Cant find |%s| on urbandictionary.com!\"' % VAR_1)\n",
"if not VAR_6:\n",
"os.system('notify-send \"Cant find |%s| on dictionary.com!\"' % VAR_1)\n",
"for definition in VAR_8[:3]:\n",
"os.system('notify-send \"no results in dictionary.com\"')\n",
"VAR_6 = True\n",
"VAR_11 = []\n",
"VAR_4 = True\n",
"VAR_9.append(FUNC_0(definition['definition']))\n",
"os.system(\"\"\"notify-send \"definitions from dictionary.com:[{}\n{}\\\"\"\"\".\n format(VAR_1 + ']\\n------------', '\\n'.join(VAR_9)))\n",
"os.system('notify-send \"Cant find |%s| on urbandictionary.com!\"' % VAR_1)\n",
"for definition in VAR_10[:3]:\n",
"VAR_9.append('------------')\n",
"VAR_6 = True\n",
"VAR_11.append(definition['definition'])\n",
"os.system(\"\"\"notify-send \"definitions from urbandictionary.com:[{}\n{}\\\"\"\"\".\n format(VAR_1 + ']\\n------------', '\\n'.join(VAR_11)))\n",
"VAR_11.append('------------')\n"
] | [
"def main():...\n",
"print(\"Starting script... press 'ctrl+c' in terminal to turn off\")\n",
"while True:\n",
"if pyperclip.paste() != word and len(pyperclip.paste().split()) < 5:\n",
"word = pyperclip.paste()\n",
"wordChc = False\n",
"req = requests.get('https://api-portal.dictionary.com/dcom/pageData/%s' % word)\n",
"wordChcURB = False\n",
"reqURB = requests.get('https://api.urbandictionary.com/v0/define?term=%s' %\n word)\n",
"data = json.loads(req.text)['data']['content'][0]['entries'][0]['posBlocks'][0\n ]['definitions']\n",
"os.system('notify-send \"Cant find |%s| on dictionary.com!\"' % word)\n",
"if not wordChc:\n",
"wordChc = True\n",
"definitions = []\n",
"dataURB = json.loads(reqURB.text)['list']\n",
"os.system('notify-send \"Cant find |%s| on urbandictionary.com!\"' % word)\n",
"if not wordChcURB:\n",
"os.system('notify-send \"Cant find |%s| on dictionary.com!\"' % word)\n",
"for definition in data[:3]:\n",
"os.system('notify-send \"no results in dictionary.com\"')\n",
"wordChcURB = True\n",
"definitionsURB = []\n",
"wordChc = True\n",
"definitions.append(cleanhtml(definition['definition']))\n",
"os.system(\"\"\"notify-send \"definitions from dictionary.com:[{}\n{}\\\"\"\"\".\n format(word + ']\\n------------', '\\n'.join(definitions)))\n",
"os.system('notify-send \"Cant find |%s| on urbandictionary.com!\"' % word)\n",
"for definition in dataURB[:3]:\n",
"definitions.append('------------')\n",
"wordChcURB = True\n",
"definitionsURB.append(definition['definition'])\n",
"os.system(\"\"\"notify-send \"definitions from urbandictionary.com:[{}\n{}\\\"\"\"\".\n format(word + ']\\n------------', '\\n'.join(definitionsURB)))\n",
"definitionsURB.append('------------')\n"
] | [
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
2,
0
] | [
"FunctionDef'",
"Expr'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"For",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"For",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_5(VAR_7):...\n",
"VAR_11 = f\"\"\"string{VAR_0} AS p INNER JOIN {VAR_1} AS pt ON\n p.product_type_id=pt.id WHERE p.id={VAR_7}\n \"\"\"\n",
"VAR_12 = create_connection()\n",
"VAR_12.close()\n",
"VAR_13 = VAR_12.cursor()\n",
"VAR_13.execute(VAR_11)\n",
"return VAR_13.fetchone()\n"
] | [
"def get_product(productId):...\n",
"sql_query = f\"\"\"\n SELECT p.ean, p.name, p.description, pt.name AS type, p.company, p.price, p.rating, p.weight, p.quantity, p.image_url\n FROM {PRODUCTS_TABLE} AS p INNER JOIN {PRODUCTS_TYPES_TABLE} AS pt ON\n p.product_type_id=pt.id WHERE p.id={productId}\n \"\"\"\n",
"connection = create_connection()\n",
"connection.close()\n",
"cursor = connection.cursor()\n",
"cursor.execute(sql_query)\n",
"return cursor.fetchone()\n"
] | [
0,
4,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Return'"
] |
[
"@contextlib.contextmanager...\n",
"VAR_3 = get_current_http_request()\n",
"VAR_4 = get_current_http_response()\n",
"if not hasattr(VAR_3, '_xsrf_token'):\n",
"VAR_5 = get_cookie(name='_xsrf', VAR_3=request)\n",
"if 'GET' != VAR_3.method.upper():\n",
"VAR_3.is_new_xsrf_token = False\n",
"VAR_5 = get_http_argument('_xsrf', optional=True) or VAR_3.headers.get('X-XSRF'\n , None)\n",
"VAR_3.arguments.pop('_xsrf', None)\n",
"if not VAR_5:\n",
"if not VAR_5:\n",
"yield\n",
"VAR_3.is_new_xsrf_token = True\n",
"VAR_3._xsrf_token = VAR_5\n",
"VAR_4.status_code = httplib.FORBIDDEN\n",
"VAR_6 = FUNC_2()\n",
"VAR_5 = uuid.uuid4().get_hex()\n",
"VAR_0.warn('XSRF token not found: request is %(request)s', {'request': str(\n VAR_3)})\n",
"if VAR_6 != VAR_5:\n",
"VAR_0.debug('assigned XSRF token: %(token)s from %(method)s %(path)s', {\n 'token': VAR_5, 'method': VAR_3.method, 'path': VAR_3.path})\n",
"VAR_0.warn(\n 'XSRF token invalid: request is %(request)s, expected is %(expected_token)s, actual is %(token)s'\n , {'request': VAR_3, 'expected_token': VAR_6, 'token': VAR_5})\n"
] | [
"@contextlib.contextmanager...\n",
"request = get_current_http_request()\n",
"response = get_current_http_response()\n",
"if not hasattr(request, '_xsrf_token'):\n",
"token = get_cookie(name='_xsrf', request=request)\n",
"if 'GET' != request.method.upper():\n",
"request.is_new_xsrf_token = False\n",
"token = get_http_argument('_xsrf', optional=True) or request.headers.get(\n 'X-XSRF', None)\n",
"request.arguments.pop('_xsrf', None)\n",
"if not token:\n",
"if not token:\n",
"yield\n",
"request.is_new_xsrf_token = True\n",
"request._xsrf_token = token\n",
"response.status_code = httplib.FORBIDDEN\n",
"expected_token = xsrf_token()\n",
"token = uuid.uuid4().get_hex()\n",
"LOGGER.warn('XSRF token not found: request is %(request)s', {'request': str\n (request)})\n",
"if expected_token != token:\n",
"LOGGER.debug('assigned XSRF token: %(token)s from %(method)s %(path)s', {\n 'token': token, 'method': request.method, 'path': request.path})\n",
"LOGGER.warn(\n 'XSRF token invalid: request is %(request)s, expected is %(expected_token)s, actual is %(token)s'\n , {'request': request, 'expected_token': expected_token, 'token': token})\n"
] | [
0,
0,
0,
0,
0,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_18(self):...\n",
"VAR_35 = []\n",
"for VAR_22, VAR_27, VAR_24 in self._handlers:\n",
"if not VAR_24:\n",
"if VAR_35:\n",
"VAR_35.append(VAR_27 or repr(VAR_22))\n"
] | [
"def _check_handlers(self):...\n",
"unhandled = []\n",
"for handle_msg, name, required in self._handlers:\n",
"if not required:\n",
"if unhandled:\n",
"unhandled.append(name or repr(handle_msg))\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"For",
"Condition",
"Condition",
"Expr'"
] |
[
"import calendar\n",
"from datetime import date as libdate\n",
"import tornado\n",
"import tornado.gen\n",
"VAR_0 = ['T1', 'T2', 'gas_pressure', 'boilers_all', 'boilers_in_use',\n 'torchs_in_use', 'boilers_reserve', 'boilers_in_repair',\n 'net_pumps_in_work', 'net_pumps_reserve', 'net_pumps_in_repair',\n 'all_day_expected_temp1', 'all_day_expected_temp2',\n 'all_day_real_temp1', 'all_day_real_temp2', 'all_night_expected_temp1',\n 'all_night_expected_temp2', 'all_night_real_temp1',\n 'all_night_real_temp2', 'net_pressure1', 'net_pressure2',\n 'net_water_consum_expected_ph', 'net_water_consum_real_ph',\n 'make_up_water_consum_expected_ph', 'make_up_water_consum_real_ph',\n 'make_up_water_consum_real_pd', 'make_up_water_consum_real_pm',\n 'hardness', 'transparency']\n",
"@tornado.gen.coroutine...\n",
"VAR_17 = 'string'.format(','.join(VAR_4))\n",
"VAR_18 = VAR_2, VAR_3\n",
"VAR_19 = yield VAR_1.execute(query=sql, VAR_18=params)\n",
"VAR_20 = {}\n",
"VAR_21 = VAR_19.fetchone()\n",
"while VAR_21:\n",
"VAR_33 = VAR_21[0]\n",
"return VAR_20\n",
"VAR_11 = VAR_21[1]\n",
"VAR_34 = {}\n",
"if VAR_33 in VAR_20:\n",
"VAR_34 = VAR_20[VAR_33]\n",
"VAR_20[VAR_33] = VAR_34\n",
"for VAR_36 in range(2, len(VAR_4) + 2):\n",
"VAR_40 = VAR_21[VAR_36]\n",
"VAR_21 = VAR_19.fetchone()\n",
"VAR_41 = VAR_4[VAR_36 - 2]\n",
"VAR_42 = {}\n",
"if VAR_41 in VAR_34:\n",
"VAR_42 = VAR_34[VAR_41]\n",
"VAR_34[VAR_41] = VAR_42\n",
"VAR_42[VAR_11] = VAR_40\n"
] | [
"import calendar\n",
"from datetime import date as libdate\n",
"import tornado\n",
"import tornado.gen\n",
"boiler_room_report_cols = ['T1', 'T2', 'gas_pressure', 'boilers_all',\n 'boilers_in_use', 'torchs_in_use', 'boilers_reserve',\n 'boilers_in_repair', 'net_pumps_in_work', 'net_pumps_reserve',\n 'net_pumps_in_repair', 'all_day_expected_temp1',\n 'all_day_expected_temp2', 'all_day_real_temp1', 'all_day_real_temp2',\n 'all_night_expected_temp1', 'all_night_expected_temp2',\n 'all_night_real_temp1', 'all_night_real_temp2', 'net_pressure1',\n 'net_pressure2', 'net_water_consum_expected_ph',\n 'net_water_consum_real_ph', 'make_up_water_consum_expected_ph',\n 'make_up_water_consum_real_ph', 'make_up_water_consum_real_pd',\n 'make_up_water_consum_real_pm', 'hardness', 'transparency']\n",
"@tornado.gen.coroutine...\n",
"sql = (\n 'SELECT boiler_room_id, DAY(date), {} FROM boiler_room_reports JOIN reports ON(report_id = reports.id) WHERE YEAR(date) = %s AND MONTH(date) = %s'\n .format(','.join(columns)))\n",
"params = year, month\n",
"cursor = yield tx.execute(query=sql, params=params)\n",
"boilers = {}\n",
"row = cursor.fetchone()\n",
"while row:\n",
"boiler_id = row[0]\n",
"return boilers\n",
"day = row[1]\n",
"parameters = {}\n",
"if boiler_id in boilers:\n",
"parameters = boilers[boiler_id]\n",
"boilers[boiler_id] = parameters\n",
"for i in range(2, len(columns) + 2):\n",
"val = row[i]\n",
"row = cursor.fetchone()\n",
"col = columns[i - 2]\n",
"values = {}\n",
"if col in parameters:\n",
"values = parameters[col]\n",
"parameters[col] = values\n",
"values[day] = val\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Import'",
"ImportFrom'",
"Import'",
"Import'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"For",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'"
] |
[
"@tornado.web.asynchronous...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_6 = tornado.concurrent.Future()\n",
"VAR_12 = users.get_user_by_cookie(self.get_cookie('user_active_login',\n default=''))\n",
"def FUNC_7(VAR_13, VAR_2, VAR_5, VAR_12):...\n",
"VAR_26 = VAR_13.request.body\n",
"VAR_13.request.body = None\n",
"VAR_2 = FUNC_1(VAR_2)\n",
"db.Filesystem.mkfile(VAR_2, VAR_5, VAR_12.username, VAR_26)\n",
"VAR_6.set_result('bzs_upload_success')\n",
"tornado.ioloop.IOLoop.instance().add_callback(FUNC_7, self, VAR_2, VAR_5,\n VAR_12)\n",
"VAR_14 = yield VAR_6\n",
"self.set_status(200, 'OK')\n",
"self.add_header('Cache-Control', 'max-age=0')\n",
"self.add_header('Connection', 'close')\n",
"self.add_header('Content-Type', 'text/html')\n",
"self.add_header('Content-Length', str(len(VAR_14)))\n",
"self.write(VAR_14)\n",
"self.flush()\n",
"self.finish()\n",
"return self\n"
] | [
"@tornado.web.asynchronous...\n",
"\"\"\"docstring\"\"\"\n",
"future = tornado.concurrent.Future()\n",
"working_user = users.get_user_by_cookie(self.get_cookie('user_active_login',\n default=''))\n",
"def save_file_async(alter_ego, target_path, file_name, working_user):...\n",
"upload_data = alter_ego.request.body\n",
"alter_ego.request.body = None\n",
"target_path = decode_hexed_b64_to_str(target_path)\n",
"db.Filesystem.mkfile(target_path, file_name, working_user.username, upload_data\n )\n",
"future.set_result('bzs_upload_success')\n",
"tornado.ioloop.IOLoop.instance().add_callback(save_file_async, self,\n target_path, file_name, working_user)\n",
"response_temp = yield future\n",
"self.set_status(200, 'OK')\n",
"self.add_header('Cache-Control', 'max-age=0')\n",
"self.add_header('Connection', 'close')\n",
"self.add_header('Content-Type', 'text/html')\n",
"self.add_header('Content-Length', str(len(response_temp)))\n",
"self.write(response_temp)\n",
"self.flush()\n",
"self.finish()\n",
"return self\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Assign'",
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Return'"
] |
[
"def FUNC_8(self, VAR_13):...\n",
"VAR_3 = VAR_13.split()\n",
"VAR_27 = self.yml\n",
"for subkey in VAR_3:\n",
"VAR_27 = VAR_27.get(subkey)\n",
"return VAR_27\n",
"if VAR_27 is None:\n"
] | [
"def subtree(self, yamlkeys_str):...\n",
"yamlkeys = yamlkeys_str.split()\n",
"yamlval = self.yml\n",
"for subkey in yamlkeys:\n",
"yamlval = yamlval.get(subkey)\n",
"return yamlval\n",
"if yamlval is None:\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Return'",
"Condition"
] |
[
"def FUNC_15(self, VAR_21):...\n",
"self.command('select ' + str(VAR_21), ['Core number', 'Core state',\n 'Debug entry cause', 'Current PC', 'Current CPSR'], 'Error selecting core')\n"
] | [
"def select_core(self, core):...\n",
"self.command('select ' + str(core), ['Core number', 'Core state',\n 'Debug entry cause', 'Current PC', 'Current CPSR'], 'Error selecting core')\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"async def FUNC_3():...\n",
"VAR_12.channel.send('Command list:\\n' + '\\n' +\n '`help` - Shows this help text\\n' +\n '`whitelist` - Add user(s) to the whitelist')\n"
] | [
"async def help():...\n",
"message.channel.send('Command list:\\n' + '\\n' +\n '`help` - Shows this help text\\n' +\n '`whitelist` - Add user(s) to the whitelist')\n"
] | [
0,
0
] | [
"AsyncFunctionDef'",
"Expr'"
] |
[
"def FUNC_9(VAR_8, VAR_11, VAR_12=False, VAR_13=False, VAR_14=None, VAR_15=False...\n",
"def FUNC_35(VAR_29):...\n",
"VAR_40 = VAR_29.group('name')\n",
"VAR_16 = VAR_11[VAR_40]\n",
"if VAR_15:\n",
"return re.sub(VAR_5, FUNC_35, VAR_8)\n",
"if VAR_13 and VAR_16 == VAR_14:\n",
"return '{{{}}}'.format(VAR_40)\n",
"if VAR_12:\n",
"return str(VAR_16)\n",
"return VAR_14\n"
] | [
"def apply_wildcards(pattern, wildcards, fill_missing=False, fail_dynamic=...\n",
"def format_match(match):...\n",
"name = match.group('name')\n",
"value = wildcards[name]\n",
"if keep_dynamic:\n",
"return re.sub(_wildcard_regex, format_match, pattern)\n",
"if fail_dynamic and value == dynamic_fill:\n",
"return '{{{}}}'.format(name)\n",
"if fill_missing:\n",
"return str(value)\n",
"return dynamic_fill\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"FunctionDef'",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Condition",
"Return'",
"Condition",
"Return'",
"Return'"
] |
[
"async def FUNC_15(*VAR_8, **VAR_9):...\n",
"if time.time() - VAR_10[1] > FUNC_3.timeout:\n",
"VAR_10[0] = await VAR_1(*VAR_8, **kwargs)\n",
"return VAR_10[0]\n",
"VAR_10[1] = time.time()\n"
] | [
"async def ret(*args, **kwargs):...\n",
"if time.time() - cache[1] > cache_page.timeout:\n",
"cache[0] = await func(*args, **kwargs)\n",
"return cache[0]\n",
"cache[1] = time.time()\n"
] | [
0,
0,
0,
0,
0
] | [
"AsyncFunctionDef'",
"Condition",
"Assign'",
"Return'",
"Assign'"
] |
[
"def FUNC_14(self, VAR_10, *VAR_11):...\n",
"if self._parts is None:\n",
"VAR_2 = self.charset\n",
"if not VAR_11:\n",
"if self._path is not None:\n",
"return getattr(self, '_' + VAR_10)\n",
"setattr(self, '_' + VAR_10, VAR_11[0])\n",
"VAR_7 = self._path\n",
"VAR_7 = u'' if VAR_2 else b''\n",
"if VAR_2:\n",
"VAR_7 = url_unescape(b(VAR_7, VAR_2)).decode(VAR_2)\n",
"VAR_7 = url_unescape(VAR_7)\n",
"VAR_17 = u'/'\n",
"VAR_17 = b'/'\n",
"self._path = None\n",
"if VAR_7.startswith(VAR_17):\n",
"VAR_7 = VAR_7[1:]\n",
"if VAR_7.endswith(VAR_17):\n",
"self._leading_slash = True\n",
"VAR_7 = VAR_7[:-1]\n",
"if VAR_7 == '':\n",
"self._trailing_slash = True\n",
"self._parts = []\n",
"self._parts = VAR_7.split(VAR_17)\n"
] | [
"def _parse(self, name, *args):...\n",
"if self._parts is None:\n",
"charset = self.charset\n",
"if not args:\n",
"if self._path is not None:\n",
"return getattr(self, '_' + name)\n",
"setattr(self, '_' + name, args[0])\n",
"path = self._path\n",
"path = u'' if charset else b''\n",
"if charset:\n",
"path = url_unescape(b(path, charset)).decode(charset)\n",
"path = url_unescape(path)\n",
"slash = u'/'\n",
"slash = b'/'\n",
"self._path = None\n",
"if path.startswith(slash):\n",
"path = path[1:]\n",
"if path.endswith(slash):\n",
"self._leading_slash = True\n",
"path = path[:-1]\n",
"if path == '':\n",
"self._trailing_slash = True\n",
"self._parts = []\n",
"self._parts = path.split(slash)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Condition",
"Condition",
"Return'",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_0(self):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_11 = self.cleaned_data['title']\n",
"if not VAR_0.match(VAR_11):\n",
"VAR_12 = ChangeSet.objects.filter(old_title=title).count()\n",
"if VAR_12 > 0:\n",
"return VAR_11\n"
] | [
"def clean_title(self):...\n",
"\"\"\"docstring\"\"\"\n",
"title = self.cleaned_data['title']\n",
"if not wikiword_pattern.match(title):\n",
"cs = ChangeSet.objects.filter(old_title=title).count()\n",
"if cs > 0:\n",
"return title\n"
] | [
0,
0,
0,
0,
6,
6,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Return'"
] |
[
"def __init__(self, VAR_1):...\n",
"self.server = VAR_1.get('etcd_server', '127.0.0.1')\n",
"self.port = int(VAR_1.get('etcd_port', 4001))\n",
"self.namespace = VAR_1.get('namespace', '/custodia')\n",
"self.etcd = etcd.Client(self.server, self.port)\n",
"FUNC_0('Error creating namespace %s: [%r]' % (self.namespace, repr(err)))\n",
"self.etcd.write(self.namespace, None, dir=True)\n"
] | [
"def __init__(self, config):...\n",
"self.server = config.get('etcd_server', '127.0.0.1')\n",
"self.port = int(config.get('etcd_port', 4001))\n",
"self.namespace = config.get('namespace', '/custodia')\n",
"self.etcd = etcd.Client(self.server, self.port)\n",
"log_error('Error creating namespace %s: [%r]' % (self.namespace, repr(err)))\n",
"self.etcd.write(self.namespace, None, dir=True)\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_9(VAR_12):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_30 = []\n",
"VAR_31 = []\n",
"VAR_32 = CommerceConfiguration.current()\n",
"VAR_33 = {'username': VAR_12.username}\n",
"VAR_34 = VAR_32.is_cache_enabled\n",
"VAR_35 = VAR_32.CACHE_KEY + '.' + str(VAR_12.id) if VAR_34 else None\n",
"VAR_36 = ecommerce_api_client(VAR_12)\n",
"VAR_37 = get_edx_api_data(VAR_32, 'orders', VAR_36=api, querystring=\n user_query, VAR_35=cache_key)\n",
"for order in VAR_37:\n",
"if order['status'].lower() == 'complete':\n",
"return VAR_31\n",
"VAR_47 = datetime.strptime(order['date_placed'], '%Y-%m-%dT%H:%M:%SZ')\n",
"VAR_48 = {'number': order['number'], 'price': order['total_excl_tax'],\n 'order_date': strftime_localized(VAR_47, 'SHORT_DATE'), 'receipt_url':\n EcommerceService().get_receipt_page_url(order['number']), 'lines':\n order['lines']}\n",
"VAR_31.append(VAR_48)\n"
] | [
"def get_user_orders(user):...\n",
"\"\"\"docstring\"\"\"\n",
"no_data = []\n",
"user_orders = []\n",
"commerce_configuration = CommerceConfiguration.current()\n",
"user_query = {'username': user.username}\n",
"use_cache = commerce_configuration.is_cache_enabled\n",
"cache_key = commerce_configuration.CACHE_KEY + '.' + str(user.id\n ) if use_cache else None\n",
"api = ecommerce_api_client(user)\n",
"commerce_user_orders = get_edx_api_data(commerce_configuration, 'orders',\n api=api, querystring=user_query, cache_key=cache_key)\n",
"for order in commerce_user_orders:\n",
"if order['status'].lower() == 'complete':\n",
"return user_orders\n",
"date_placed = datetime.strptime(order['date_placed'], '%Y-%m-%dT%H:%M:%SZ')\n",
"order_data = {'number': order['number'], 'price': order['total_excl_tax'],\n 'order_date': strftime_localized(date_placed, 'SHORT_DATE'),\n 'receipt_url': EcommerceService().get_receipt_page_url(order['number']),\n 'lines': order['lines']}\n",
"user_orders.append(order_data)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Condition",
"Return'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_0(VAR_0, VAR_1, VAR_2=None, VAR_3=False):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_1 = posixpath.normpath(unquote(VAR_1))\n",
"VAR_1 = VAR_1.lstrip('/')\n",
"VAR_10 = ''\n",
"for VAR_18 in VAR_1.split('/'):\n",
"if not VAR_18:\n",
"if VAR_10 and VAR_1 != VAR_10:\n",
"VAR_17, VAR_18 = os.path.splitdrive(VAR_18)\n",
"return HttpResponseRedirect(VAR_10)\n",
"VAR_6 = os.path.join(VAR_2, VAR_10)\n",
"VAR_19, VAR_18 = os.path.split(VAR_18)\n",
"if os.path.isdir(VAR_6):\n",
"if VAR_18 in (os.curdir, os.pardir):\n",
"if VAR_3:\n",
"if not os.path.exists(VAR_6):\n",
"VAR_10 = os.path.join(VAR_10, VAR_18).replace('\\\\', '/')\n",
"return FUNC_1(VAR_10, VAR_6)\n",
"VAR_11 = os.stat(VAR_6)\n",
"if not FUNC_2(VAR_0.META.get('HTTP_IF_MODIFIED_SINCE'), VAR_11.st_mtime,\n",
"return HttpResponseNotModified()\n",
"VAR_12, VAR_13 = mimetypes.guess_type(VAR_6)\n",
"VAR_12 = VAR_12 or 'application/octet-stream'\n",
"VAR_14 = FileResponse(open(VAR_6, 'rb'), VAR_12=content_type)\n",
"VAR_14['Last-Modified'] = http_date(VAR_11.st_mtime)\n",
"if stat.S_ISREG(VAR_11.st_mode):\n",
"VAR_14['Content-Length'] = VAR_11.st_size\n",
"if VAR_13:\n",
"VAR_14['Content-Encoding'] = VAR_13\n",
"return VAR_14\n"
] | [
"def serve(request, path, document_root=None, show_indexes=False):...\n",
"\"\"\"docstring\"\"\"\n",
"path = posixpath.normpath(unquote(path))\n",
"path = path.lstrip('/')\n",
"newpath = ''\n",
"for part in path.split('/'):\n",
"if not part:\n",
"if newpath and path != newpath:\n",
"drive, part = os.path.splitdrive(part)\n",
"return HttpResponseRedirect(newpath)\n",
"fullpath = os.path.join(document_root, newpath)\n",
"head, part = os.path.split(part)\n",
"if os.path.isdir(fullpath):\n",
"if part in (os.curdir, os.pardir):\n",
"if show_indexes:\n",
"if not os.path.exists(fullpath):\n",
"newpath = os.path.join(newpath, part).replace('\\\\', '/')\n",
"return directory_index(newpath, fullpath)\n",
"statobj = os.stat(fullpath)\n",
"if not was_modified_since(request.META.get('HTTP_IF_MODIFIED_SINCE'),\n",
"return HttpResponseNotModified()\n",
"content_type, encoding = mimetypes.guess_type(fullpath)\n",
"content_type = content_type or 'application/octet-stream'\n",
"response = FileResponse(open(fullpath, 'rb'), content_type=content_type)\n",
"response['Last-Modified'] = http_date(statobj.st_mtime)\n",
"if stat.S_ISREG(statobj.st_mode):\n",
"response['Content-Length'] = statobj.st_size\n",
"if encoding:\n",
"response['Content-Encoding'] = encoding\n",
"return response\n"
] | [
0,
0,
6,
6,
6,
6,
6,
6,
6,
6,
6,
6,
0,
6,
0,
0,
6,
6,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"For",
"Condition",
"Condition",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"Condition",
"Condition",
"Assign'",
"Return'",
"Assign'",
"Condition",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Return'"
] |
[
"def FUNC_43(self, VAR_21=None):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_32 = list()\n",
"VAR_21 = VAR_21 or self.get_columns_list()\n",
"for VAR_14 in VAR_21:\n",
"if not self.is_relation(VAR_14):\n",
"return VAR_32\n",
"if hasattr(self.obj, VAR_14):\n",
"if not hasattr(getattr(self.obj, VAR_14), '__call__') or hasattr(getattr(\n",
"VAR_32.append(VAR_14)\n",
"VAR_32.append(VAR_14)\n"
] | [
"def get_order_columns_list(self, list_columns=None):...\n",
"\"\"\"docstring\"\"\"\n",
"ret_lst = list()\n",
"list_columns = list_columns or self.get_columns_list()\n",
"for col_name in list_columns:\n",
"if not self.is_relation(col_name):\n",
"return ret_lst\n",
"if hasattr(self.obj, col_name):\n",
"if not hasattr(getattr(self.obj, col_name), '__call__') or hasattr(getattr(\n",
"ret_lst.append(col_name)\n",
"ret_lst.append(col_name)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"For",
"Condition",
"Return'",
"Condition",
"Condition",
"Expr'",
"Expr'"
] |
[
"def __init__(self, VAR_24):...\n",
"QNetworkAccessManager.__init__(self)\n",
"VAR_27 = QUrl('http://localhost:%d/events' % VAR_24)\n",
"self.request = QNetworkRequest(VAR_27)\n",
"self.failed_attempts = 0\n",
"self.connect_timer = QTimer()\n",
"self.current_event_string = ''\n",
"self.tribler_version = 'Unknown'\n",
"self.reply = None\n",
"self.emitted_tribler_started = False\n",
"self.shutting_down = False\n",
"self._logger = logging.getLogger('TriblerGUI')\n"
] | [
"def __init__(self, api_port):...\n",
"QNetworkAccessManager.__init__(self)\n",
"url = QUrl('http://localhost:%d/events' % api_port)\n",
"self.request = QNetworkRequest(url)\n",
"self.failed_attempts = 0\n",
"self.connect_timer = QTimer()\n",
"self.current_event_string = ''\n",
"self.tribler_version = 'Unknown'\n",
"self.reply = None\n",
"self.emitted_tribler_started = False\n",
"self.shutting_down = False\n",
"self._logger = logging.getLogger('TriblerGUI')\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_28(VAR_13):...\n",
"self.assertEqual('/request', VAR_13.path)\n",
"VAR_12.append('applicable')\n",
"return VAR_5\n"
] | [
"def applicable(request):...\n",
"self.assertEqual('/request', request.path)\n",
"calls.append('applicable')\n",
"return ident\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Return'"
] |
[
"@FUNC_0...\n",
"VAR_27 = VAR_10.get_transport()\n",
"VAR_7 = VAR_27.open_session()\n",
"VAR_7.invoke_shell()\n",
"VAR_0.debug(_('Reading CLI MOTD'))\n",
"self._get_output(VAR_7)\n",
"VAR_28 = 'stty columns 255'\n",
"VAR_0.debug(_(\"Setting CLI terminal width: '%s'\"), VAR_28)\n",
"VAR_7.send(VAR_28 + '\\r')\n",
"VAR_25 = self._get_output(VAR_7)\n",
"VAR_0.debug(_(\"Sending CLI command: '%s'\"), VAR_11)\n",
"VAR_7.send(VAR_11 + '\\r')\n",
"VAR_25 = self._get_output(VAR_7)\n",
"VAR_7.close()\n",
"if any(line.startswith(('% Error', 'Error:')) for line in VAR_25):\n",
"VAR_37 = _('Error executing EQL command')\n",
"return VAR_25\n",
"VAR_38 = '\\n'.join(VAR_25)\n",
"VAR_0.error(VAR_38)\n"
] | [
"@with_timeout...\n",
"transport = ssh.get_transport()\n",
"chan = transport.open_session()\n",
"chan.invoke_shell()\n",
"LOG.debug(_('Reading CLI MOTD'))\n",
"self._get_output(chan)\n",
"cmd = 'stty columns 255'\n",
"LOG.debug(_(\"Setting CLI terminal width: '%s'\"), cmd)\n",
"chan.send(cmd + '\\r')\n",
"out = self._get_output(chan)\n",
"LOG.debug(_(\"Sending CLI command: '%s'\"), command)\n",
"chan.send(command + '\\r')\n",
"out = self._get_output(chan)\n",
"chan.close()\n",
"if any(line.startswith(('% Error', 'Error:')) for line in out):\n",
"desc = _('Error executing EQL command')\n",
"return out\n",
"cmdout = '\\n'.join(out)\n",
"LOG.error(cmdout)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"For",
"Assign'",
"Return'",
"Assign'",
"Expr'"
] |
[
"def __init__(VAR_39, VAR_40, VAR_41, VAR_42, VAR_43, VAR_44, VAR_45, VAR_46):...\n",
"VAR_39.returncode = None\n",
"VAR_6 = [sys.executable, bot_main.THIS_FILE, 'run_isolated']\n",
"self.assertEqual(VAR_6, VAR_40[:len(VAR_6)])\n",
"self.assertEqual(True, VAR_41)\n",
"self.assertEqual(subprocess42.PIPE, VAR_43)\n",
"self.assertEqual(subprocess42.STDOUT, VAR_44)\n",
"self.assertEqual(subprocess42.PIPE, VAR_45)\n",
"self.assertEqual(sys.platform != 'win32', VAR_46)\n"
] | [
"def __init__(self2, cmd, detached, cwd, stdout, stderr, stdin, close_fds):...\n",
"self2.returncode = None\n",
"expected = [sys.executable, bot_main.THIS_FILE, 'run_isolated']\n",
"self.assertEqual(expected, cmd[:len(expected)])\n",
"self.assertEqual(True, detached)\n",
"self.assertEqual(subprocess42.PIPE, stdout)\n",
"self.assertEqual(subprocess42.STDOUT, stderr)\n",
"self.assertEqual(subprocess42.PIPE, stdin)\n",
"self.assertEqual(sys.platform != 'win32', close_fds)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_2():...\n",
"VAR_11 = request.args.get('page') or VAR_1\n",
"VAR_12 = request.args.get('perPage') or VAR_2\n",
"VAR_13 = request.args.get('rating') or VAR_3\n",
"VAR_14 = request.args.get('search') or None\n",
"VAR_8 = {'page': int(VAR_11), 'perPage': int(VAR_12), 'rating': int(VAR_13),\n 'search': VAR_14}\n",
"return VAR_8\n"
] | [
"def get_filters():...\n",
"page = request.args.get('page') or DEFAULT_PAGE\n",
"perPage = request.args.get('perPage') or DEFAULT_PER_PAGE\n",
"rating = request.args.get('rating') or DEFAULT_RATING\n",
"search = request.args.get('search') or None\n",
"filters = {'page': int(page), 'perPage': int(perPage), 'rating': int(rating\n ), 'search': search}\n",
"return filters\n"
] | [
0,
0,
0,
0,
0,
4,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_0(VAR_0='_Test Event', VAR_1=None):...\n",
"\"\"\"docstring\"\"\"\n",
"from frappe.utils import get_datetime\n",
"VAR_2 = frappe.get_doc({'doctype': 'Event', 'subject': VAR_0, 'event_type':\n 'Public', 'starts_on': get_datetime(VAR_1)}).insert(ignore_permissions=True\n )\n",
"return VAR_2\n"
] | [
"def create_event(subject='_Test Event', starts_on=None):...\n",
"\"\"\"docstring\"\"\"\n",
"from frappe.utils import get_datetime\n",
"event = frappe.get_doc({'doctype': 'Event', 'subject': subject,\n 'event_type': 'Public', 'starts_on': get_datetime(starts_on)}).insert(\n ignore_permissions=True)\n",
"return event\n"
] | [
0,
0,
0,
0,
4
] | [
"FunctionDef'",
"Docstring",
"ImportFrom'",
"Assign'",
"Return'"
] |
[
"def __str__(self):...\n",
"return f\"Instance of a connector to the database. The connection is {'opened' if self.conn else 'closed'}. SSH tunnel is {'opened' if self.tunnel_opened else 'closed'}.\"\n"
] | [
"def __str__(self):...\n",
"return f\"Instance of a connector to the database. The connection is {'opened' if self.conn else 'closed'}. SSH tunnel is {'opened' if self.tunnel_opened else 'closed'}.\"\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"@VAR_0.route('/<page_name>')...\n",
"VAR_3 = VAR_1.query('string' % VAR_2)\n",
"VAR_4 = VAR_3.namedresult()\n",
"VAR_5 = False\n",
"VAR_6 = False\n",
"if len(VAR_4) < 1:\n",
"VAR_7 = ''\n",
"VAR_6 = True\n",
"if len(VAR_7) > 0:\n",
"VAR_7 = VAR_4[0].content\n",
"VAR_5 = True\n",
"VAR_7 = markdown.markdown(wiki_linkify(VAR_7))\n",
"return render_template('pageholder.html', VAR_6=page_is_taken, VAR_2=\n page_name, markdown=markdown, wiki_linkify=wiki_linkify, VAR_5=\n has_content, VAR_7=content)\n"
] | [
"@app.route('/<page_name>')...\n",
"query = db.query(\n \"select page_content.content, page.id as page_id, page_content.id as content_id from page, page_content where page.id = page_content.page_id and page.page_name = '%s' order by page_content.id desc limit 1\"\n % page_name)\n",
"wiki_page = query.namedresult()\n",
"has_content = False\n",
"page_is_taken = False\n",
"if len(wiki_page) < 1:\n",
"content = ''\n",
"page_is_taken = True\n",
"if len(content) > 0:\n",
"content = wiki_page[0].content\n",
"has_content = True\n",
"content = markdown.markdown(wiki_linkify(content))\n",
"return render_template('pageholder.html', page_is_taken=page_is_taken,\n page_name=page_name, markdown=markdown, wiki_linkify=wiki_linkify,\n has_content=has_content, content=content)\n"
] | [
0,
4,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_2(self, VAR_1, VAR_7, VAR_8, VAR_9, VAR_4=None):...\n",
"if VAR_4 is None:\n",
"VAR_4 = {}\n",
"VAR_29 = super(CLASS_0, self).view_header_get(VAR_1, VAR_7, VAR_8, VAR_9, VAR_4\n )\n",
"if VAR_29:\n",
"return VAR_29\n",
"if VAR_4.get('active_id', False) and VAR_4.get('active_model'\n",
"return _('Products: ') + self.pool.get('stock.location').browse(VAR_1,\n VAR_7, VAR_4['active_id'], VAR_4).name\n",
"return VAR_29\n"
] | [
"def view_header_get(self, cr, user, view_id, view_type, context=None):...\n",
"if context is None:\n",
"context = {}\n",
"res = super(product_product, self).view_header_get(cr, user, view_id,\n view_type, context)\n",
"if res:\n",
"return res\n",
"if context.get('active_id', False) and context.get('active_model'\n",
"return _('Products: ') + self.pool.get('stock.location').browse(cr, user,\n context['active_id'], context).name\n",
"return res\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_4(VAR_0):...\n",
"VAR_2 = VAR_0.GET.get('url', None)\n",
"VAR_15 = FUNC_5(VAR_2)\n",
"while VAR_15 != VAR_2:\n",
"VAR_2 = VAR_15\n",
"return JsonResponse({'url': VAR_15})\n",
"VAR_15 = FUNC_5(VAR_2)\n"
] | [
"def expand_url(request):...\n",
"url = request.GET.get('url', None)\n",
"exurl = expand(url)\n",
"while exurl != url:\n",
"url = exurl\n",
"return JsonResponse({'url': exurl})\n",
"exurl = expand(url)\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Assign'"
] |
[
"def FUNC_31(VAR_16, VAR_22, VAR_28):...\n",
"VAR_53 = 'string'.format(VAR_22, VAR_28, VAR_28)\n",
"print(VAR_53)\n",
"VAR_54 = VAR_16.exec(VAR_53)\n",
"VAR_54 = [[VAR_41[0], int(VAR_41[1])] for VAR_41 in VAR_54]\n",
"return VAR_54\n"
] | [
"def get_bracket_placings_in_scene(db, scene, tag):...\n",
"sql = (\n \"select distinct matches.date, placings.place from placings join matches on matches.url=placings.url where scene='{}' and ((player1='{}' and placings.player=player1) or (player2='{}' and placings.player=player2));\"\n .format(scene, tag, tag))\n",
"print(sql)\n",
"res = db.exec(sql)\n",
"res = [[r[0], int(r[1])] for r in res]\n",
"return res\n"
] | [
0,
4,
4,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_17(self, VAR_9, VAR_10):...\n",
"return VAR_9[VAR_10:VAR_10 + 16].split(b'\\x00', 1)[0]\n"
] | [
"def _format_single_interface_name(self, sock, offset):...\n",
"return sock[offset:offset + 16].split(b'\\x00', 1)[0]\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_6(self, VAR_51):...\n",
"VAR_81 = VAR_51\n",
"VAR_51 = FUNC_3(VAR_51)\n",
"if not VAR_51:\n",
"return self.error(FUNC_4(VAR_81))\n",
"VAR_15 = Account._by_name(VAR_51, True)\n",
"return VAR_51\n",
"return self.error(errors.USERNAME_TAKEN)\n"
] | [
"def run(self, user_name):...\n",
"original_user_name = user_name\n",
"user_name = chkuser(user_name)\n",
"if not user_name:\n",
"return self.error(whyuserbad(original_user_name))\n",
"a = Account._by_name(user_name, True)\n",
"return user_name\n",
"return self.error(errors.USERNAME_TAKEN)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Assign'",
"Return'",
"Return'"
] |
[
"def __repr__(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return self.__module__ + '.' + self.__class__.__name__ + '\\nInstance: ' + self.name\n"
] | [
"def __repr__(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return self.__module__ + '.' + self.__class__.__name__ + '\\nInstance: ' + self.name\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def __eq__(self, VAR_35):...\n",
"return self.__class__ == VAR_35.__class__ and self.inner_type == VAR_35.inner_type\n"
] | [
"def __eq__(self, other):...\n",
"return self.__class__ == other.__class__ and self.inner_type == other.inner_type\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_5(self, VAR_18):...\n",
"self.setResponseCode(302)\n",
"self.setHeader(b'location', VAR_18)\n"
] | [
"def redirect(self, url):...\n",
"self.setResponseCode(302)\n",
"self.setHeader(b'location', url)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'"
] |
[
"def FUNC_4(self, VAR_3):...\n",
"\"\"\"docstring\"\"\"\n",
"if VAR_3[1] == '0':\n",
"return self.cursor.execute(\n 'select * from item where item.name = \"%s\"' % VAR_3[0])\n",
"return self.cursor.execute('string' % (VAR_3[0], VAR_3[1]))\n"
] | [
"def find_item_name(self, nameid):...\n",
"\"\"\"docstring\"\"\"\n",
"if nameid[1] == '0':\n",
"return self.cursor.execute(\n 'select * from item where item.name = \"%s\"' % nameid[0])\n",
"return self.cursor.execute(\n 'select item.id, item.name, item.shoppinglistid, itemtranslation.id, itemtranslation.itemid, itemtranslation.itemlanguageid, itemtranslation.translation from item, itemtranslation where item.name = \"%s\" and itemtranslation.itemlanguageid = \"%s\" and itemtranslation.itemid = item.id'\n % (nameid[0], nameid[1]))\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_10(self):...\n",
"if self._IsServerAlive():\n",
"return BaseRequest.PostDataToHandler(BuildRequestData(), 'defined_subcommands')\n",
"return []\n"
] | [
"def GetDefinedSubcommands(self):...\n",
"if self._IsServerAlive():\n",
"return BaseRequest.PostDataToHandler(BuildRequestData(), 'defined_subcommands')\n",
"return []\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Return'"
] |
[
"@app.route('/upload', methods=['POST'])...\n",
"VAR_2 = {'secret': app.config['G_CAPTCHA_SECRET'], 'response': request.form\n ['g-recaptcha-response'], 'remoteip': request.remote_addr}\n",
"VAR_3 = requests.post(app.config['G_CAPTCHA_VERIFY'], VAR_2=data).json()\n",
"if VAR_3['success']:\n",
"VAR_1 = ProcessingForm()\n",
"flash('Error: %s' % ', '.join(VAR_3['error-codes']))\n",
"if not VAR_1.validate_on_submit():\n",
"return redirect(url_for('experiment', title='Try it Out!', sitekey=app.\n config['G_CAPTCHA_SITEKEY'], VAR_1=form, files=utils.SAMPLE_FILES))\n",
"for field, errors in VAR_1.errors.items():\n",
"VAR_4 = tempfile.mkdtemp(dir=app.config['UPLOAD_FOLDER'], prefix='')\n",
"for e in errors:\n",
"VAR_7 = os.path.basename(VAR_4)\n",
"flash('Error in %s: %s' % (getattr(VAR_1, field).label.text, e))\n",
"request.files['testcsv'].save(os.path.join(VAR_4, app.config['TESTING_FN']))\n",
"if request.files['trainingcsv'].filename != '':\n",
"request.files['trainingcsv'].save(os.path.join(VAR_4, app.config[\n 'TRAINING_FN']))\n",
"VAR_13 = FILE_MAP[request.form['trainingset']]\n",
"flash(\"Error: '%s' is not supported\" % request.form['trainingset'])\n",
"VAR_8 = '<a href=\"%s\" class=\"alert-link\">page</a>' % url_for('view', VAR_0=\n session_id)\n",
"copyfile(os.path.join(app.config['TRAINING_FOLDER'], VAR_13), os.path.join(\n VAR_4, app.config['TRAINING_FN']))\n",
"VAR_9 = 'Success! To view progress later, bookmark the %s' % VAR_8\n",
"flash(Markup(VAR_9))\n",
"VAR_10 = open(os.path.join(VAR_4, 'logs.txt'), 'w')\n",
"VAR_11 = os.environ.copy()\n",
"VAR_11['API_KEY'] = app.config['API_KEY']\n",
"sub.Popen(['python', 'scripts/master.py', VAR_7, request.form['trainingset'\n ]], stdout=f, stderr=f, VAR_11=env)\n",
"return redirect(url_for('view', VAR_0=session_id))\n"
] | [
"@app.route('/upload', methods=['POST'])...\n",
"data = {'secret': app.config['G_CAPTCHA_SECRET'], 'response': request.form[\n 'g-recaptcha-response'], 'remoteip': request.remote_addr}\n",
"resp = requests.post(app.config['G_CAPTCHA_VERIFY'], data=data).json()\n",
"if resp['success']:\n",
"form = ProcessingForm()\n",
"flash('Error: %s' % ', '.join(resp['error-codes']))\n",
"if not form.validate_on_submit():\n",
"return redirect(url_for('experiment', title='Try it Out!', sitekey=app.\n config['G_CAPTCHA_SITEKEY'], form=form, files=utils.SAMPLE_FILES))\n",
"for field, errors in form.errors.items():\n",
"path = tempfile.mkdtemp(dir=app.config['UPLOAD_FOLDER'], prefix='')\n",
"for e in errors:\n",
"session_id = os.path.basename(path)\n",
"flash('Error in %s: %s' % (getattr(form, field).label.text, e))\n",
"request.files['testcsv'].save(os.path.join(path, app.config['TESTING_FN']))\n",
"if request.files['trainingcsv'].filename != '':\n",
"request.files['trainingcsv'].save(os.path.join(path, app.config['TRAINING_FN'])\n )\n",
"fn = FILE_MAP[request.form['trainingset']]\n",
"flash(\"Error: '%s' is not supported\" % request.form['trainingset'])\n",
"link = '<a href=\"%s\" class=\"alert-link\">page</a>' % url_for('view', sid=\n session_id)\n",
"copyfile(os.path.join(app.config['TRAINING_FOLDER'], fn), os.path.join(path,\n app.config['TRAINING_FN']))\n",
"success_txt = 'Success! To view progress later, bookmark the %s' % link\n",
"flash(Markup(success_txt))\n",
"f = open(os.path.join(path, 'logs.txt'), 'w')\n",
"env = os.environ.copy()\n",
"env['API_KEY'] = app.config['API_KEY']\n",
"sub.Popen(['python', 'scripts/master.py', session_id, request.form[\n 'trainingset']], stdout=f, stderr=f, env=env)\n",
"return redirect(url_for('view', sid=session_id))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
2,
0,
2,
0,
0,
2,
2,
2,
2,
2,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Expr'",
"Condition",
"Return'",
"For",
"Assign'",
"For",
"Assign'",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"def FUNC_2():...\n",
"VAR_11, VAR_10 = FUNC_1()\n",
"VAR_11.execute('string')\n",
"VAR_11.execute('string')\n",
"VAR_10.commit()\n",
"VAR_10.close()\n"
] | [
"def createDatabase():...\n",
"c, conn = getConnection()\n",
"c.execute(\n \"\"\"CREATE TABLE if not exists npc\n\t\t\t\t (date text, user text, race text, class text, sex text, level INTEGER, image text, legit INTEGER)\"\"\"\n )\n",
"c.execute(\n \"\"\"CREATE TABLE if not exists usage\n\t\t\t\t (id INTEGER PRIMARY KEY AUTOINCREMENT, date text, user text, command text)\"\"\"\n )\n",
"conn.commit()\n",
"conn.close()\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_9(self, VAR_13, VAR_14, VAR_15, VAR_16):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_23 = {}\n",
"self.sessid = VAR_14.routing_key\n",
"import sys\n",
"if 'callbackID' in VAR_23:\n",
"VAR_23 = json_decode(VAR_16)\n",
"if hasattr(sys, '_called_from_test'):\n",
"VAR_17['callbackID'] = VAR_23['callbackID']\n",
"log.info('OUTPUT for %s: %s' % (self.sessid, VAR_17))\n",
"VAR_10 = VAR_23['data']\n",
"VAR_17 = {'cmd': 'error', 'error': self._prepare_error_msg(e.message),\n 'code': e.code}\n",
"VAR_17['reply_timestamp'] = time()\n",
"if 'path' in VAR_10:\n",
"log.exception('Http error occurred')\n",
"self.send_output(VAR_17)\n",
"if VAR_10['path'] in settings.VIEW_URLS:\n",
"VAR_11 = Session(self.sessid)\n",
"self.current = Current(VAR_11=session, VAR_23=data)\n",
"VAR_10['view'] = VAR_10['path']\n",
"VAR_10['wf'] = VAR_10['path']\n",
"VAR_12 = {'remote_ip': VAR_23['_zops_remote_ip']}\n",
"self.current.headers = VAR_12\n",
"if 'wf' in VAR_10:\n",
"import sys\n",
"VAR_17 = self._handle_workflow(VAR_11, VAR_10, VAR_12)\n",
"if 'job' in VAR_10:\n",
"if hasattr(sys, '_called_from_test'):\n",
"self._handle_job(VAR_11, VAR_10, VAR_12)\n",
"VAR_17 = self._handle_view(VAR_11, VAR_10, VAR_12)\n",
"VAR_27 = traceback.format_exc()\n",
"return\n",
"VAR_17 = {'error': self._prepare_error_msg(VAR_27), 'code': 500}\n",
"log.exception(\"\"\"Worker error occurred with messsage body:\n%s\"\"\" % VAR_16)\n"
] | [
"def handle_message(self, ch, method, properties, body):...\n",
"\"\"\"docstring\"\"\"\n",
"input = {}\n",
"self.sessid = method.routing_key\n",
"import sys\n",
"if 'callbackID' in input:\n",
"input = json_decode(body)\n",
"if hasattr(sys, '_called_from_test'):\n",
"output['callbackID'] = input['callbackID']\n",
"log.info('OUTPUT for %s: %s' % (self.sessid, output))\n",
"data = input['data']\n",
"output = {'cmd': 'error', 'error': self._prepare_error_msg(e.message),\n 'code': e.code}\n",
"output['reply_timestamp'] = time()\n",
"if 'path' in data:\n",
"log.exception('Http error occurred')\n",
"self.send_output(output)\n",
"if data['path'] in settings.VIEW_URLS:\n",
"session = Session(self.sessid)\n",
"self.current = Current(session=session, input=data)\n",
"data['view'] = data['path']\n",
"data['wf'] = data['path']\n",
"headers = {'remote_ip': input['_zops_remote_ip']}\n",
"self.current.headers = headers\n",
"if 'wf' in data:\n",
"import sys\n",
"output = self._handle_workflow(session, data, headers)\n",
"if 'job' in data:\n",
"if hasattr(sys, '_called_from_test'):\n",
"self._handle_job(session, data, headers)\n",
"output = self._handle_view(session, data, headers)\n",
"err = traceback.format_exc()\n",
"return\n",
"output = {'error': self._prepare_error_msg(err), 'code': 500}\n",
"log.exception(\"\"\"Worker error occurred with messsage body:\n%s\"\"\" % body)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Import'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Expr'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Import'",
"Assign'",
"Condition",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Return'",
"Assign'",
"Expr'"
] |
[
"def FUNC_1(self):...\n",
"VAR_1 = self.get_secure_cookie('sid')\n",
"if not VAR_1:\n",
"return False\n",
"VAR_2 = self.session.get('email')\n",
"VAR_3 = dbapi.User()\n",
"if VAR_2 and VAR_3.get_user(VAR_2) == 0:\n",
"VAR_9 = VAR_3.get_user_all(VAR_2)\n",
"self.clear_cookies()\n",
"if VAR_9:\n",
"return False\n",
"self.time = VAR_9[4]\n",
"self.email = VAR_2\n",
"return True\n"
] | [
"def check(self):...\n",
"sid = self.get_secure_cookie('sid')\n",
"if not sid:\n",
"return False\n",
"email = self.session.get('email')\n",
"user = dbapi.User()\n",
"if email and user.get_user(email) == 0:\n",
"profile = user.get_user_all(email)\n",
"self.clear_cookies()\n",
"if profile:\n",
"return False\n",
"self.time = profile[4]\n",
"self.email = email\n",
"return True\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Return'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Expr'",
"Condition",
"Return'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_2(self, VAR_4):...\n",
"self.headers.append(('Content-Type', '%s; charset=utf-8' % VAR_0))\n",
"if isinstance(VAR_4, list) or isinstance(VAR_4, tuple):\n",
"VAR_7 = self._render_obj_list(VAR_4)\n",
"VAR_7 = self._render_single_obj(VAR_4)\n",
"self.body = json.dumps(VAR_7, indent=self.INDENT)\n"
] | [
"def render(self, objects):...\n",
"self.headers.append(('Content-Type', '%s; charset=utf-8' % CONTENT_TYPE))\n",
"if isinstance(objects, list) or isinstance(objects, tuple):\n",
"json_data = self._render_obj_list(objects)\n",
"json_data = self._render_single_obj(objects)\n",
"self.body = json.dumps(json_data, indent=self.INDENT)\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Condition",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_45(VAR_25, VAR_39):...\n",
"if self.parentfield:\n",
"return '{} #{}: {}: {}'.format(_('Row'), self.idx, _(VAR_25.label), VAR_39)\n",
"return '{}: {}'.format(_(VAR_25.label), VAR_39)\n"
] | [
"def get_msg(df, docname):...\n",
"if self.parentfield:\n",
"return '{} #{}: {}: {}'.format(_('Row'), self.idx, _(df.label), docname)\n",
"return '{}: {}'.format(_(df.label), docname)\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_5(self, VAR_6, VAR_7):...\n",
""
] | [
"def _executeSQL(self, cur, sql):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_1():...\n",
"VAR_3 = files.get_static_data('./static/home.html')\n",
"VAR_4 = users.get_user_by_cookie(self.get_cookie('user_active_login',\n default=''))\n",
"VAR_3 = preproc.preprocess_webpage(VAR_3, VAR_4)\n",
"VAR_2.set_result(VAR_3)\n"
] | [
"def get_index_html_async():...\n",
"file_data = files.get_static_data('./static/home.html')\n",
"working_user = users.get_user_by_cookie(self.get_cookie('user_active_login',\n default=''))\n",
"file_data = preproc.preprocess_webpage(file_data, working_user)\n",
"future.set_result(file_data)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_0(self):...\n",
"VAR_0 = Section('some_name')\n",
"self.uut = Lint(VAR_0, None)\n"
] | [
"def setUp(self):...\n",
"section = Section('some_name')\n",
"self.uut = Lint(section, None)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'"
] |
[
"def __init__(self, VAR_40):...\n",
"assert VAR_40 in (32, 64)\n",
"self.size = VAR_40\n"
] | [
"def __init__(self, size):...\n",
"assert size in (32, 64)\n",
"self.size = size\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assert'",
"Assign'"
] |
[
"def FUNC_20(self):...\n",
"self._ServerCleanup()\n"
] | [
"def OnVimLeave(self):...\n",
"self._ServerCleanup()\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_7(VAR_8):...\n",
"\"\"\"docstring\"\"\"\n",
"return '/logout?' + urllib.parse.urlencode({'csrf_token': form.\n generate_csrf_token(), 'dest': VAR_8})\n"
] | [
"def make_logout_url(dest_url):...\n",
"\"\"\"docstring\"\"\"\n",
"return '/logout?' + urllib.parse.urlencode({'csrf_token': form.\n generate_csrf_token(), 'dest': dest_url})\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"@FUNC_1.command(aliases=['u', 'upd'])...\n",
"\"\"\"docstring\"\"\"\n",
"if not self.updating:\n",
"self.updating = True\n",
"await VAR_1.send('Database update still in progress.')\n",
"await VAR_1.send('Database update in progress...')\n",
"VAR_6 = asyncio.get_event_loop()\n",
"await VAR_6.run_in_executor(None, to_sqlalchemy.remake)\n",
"await VAR_1.send('Database update complete.')\n",
"self.updating = False\n"
] | [
"@eddb.command(aliases=['u', 'upd'])...\n",
"\"\"\"docstring\"\"\"\n",
"if not self.updating:\n",
"self.updating = True\n",
"await ctx.send('Database update still in progress.')\n",
"await ctx.send('Database update in progress...')\n",
"loop = asyncio.get_event_loop()\n",
"await loop.run_in_executor(None, to_sqlalchemy.remake)\n",
"await ctx.send('Database update complete.')\n",
"self.updating = False\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Condition",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Assign'"
] |
[
"@staticmethod...\n",
"VAR_0 = Database()\n",
"VAR_11 = VAR_0.list_tasks(VAR_2=limit, VAR_3=offset, VAR_30='file',\n not_status=TASK_PENDING)\n",
"VAR_12 = VAR_0.list_tasks(VAR_2=limit, VAR_3=offset, VAR_30='url',\n not_status=TASK_PENDING)\n",
"VAR_9 = []\n",
"if VAR_11:\n",
"for VAR_10 in VAR_11:\n",
"if VAR_12:\n",
"VAR_27 = VAR_10.to_dict()\n",
"for VAR_10 in VAR_12:\n",
"return VAR_9\n",
"VAR_27['sample'] = VAR_0.view_sample(VAR_27['sample_id']).to_dict()\n",
"VAR_27 = VAR_10.to_dict()\n",
"VAR_28 = os.path.basename(VAR_27['target'])\n",
"if VAR_0.view_errors(VAR_10.id):\n",
"VAR_27.update({'filename': VAR_28})\n",
"VAR_27['errors'] = True\n",
"VAR_9.append(VAR_27)\n",
"if VAR_0.view_errors(VAR_10.id):\n",
"VAR_27['errors'] = True\n",
"VAR_9.append(VAR_27)\n"
] | [
"@staticmethod...\n",
"db = Database()\n",
"tasks_files = db.list_tasks(limit=limit, offset=offset, category='file',\n not_status=TASK_PENDING)\n",
"tasks_urls = db.list_tasks(limit=limit, offset=offset, category='url',\n not_status=TASK_PENDING)\n",
"data = []\n",
"if tasks_files:\n",
"for task in tasks_files:\n",
"if tasks_urls:\n",
"new = task.to_dict()\n",
"for task in tasks_urls:\n",
"return data\n",
"new['sample'] = db.view_sample(new['sample_id']).to_dict()\n",
"new = task.to_dict()\n",
"filename = os.path.basename(new['target'])\n",
"if db.view_errors(task.id):\n",
"new.update({'filename': filename})\n",
"new['errors'] = True\n",
"data.append(new)\n",
"if db.view_errors(task.id):\n",
"new['errors'] = True\n",
"data.append(new)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"For",
"Condition",
"Assign'",
"For",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Expr'",
"Condition",
"Assign'",
"Expr'"
] |
[
"@tornado.web.authenticated...\n",
"self.render('../config.html', cfg=cfgDAO.loadConfig())\n"
] | [
"@tornado.web.authenticated...\n",
"self.render('../config.html', cfg=cfgDAO.loadConfig())\n"
] | [
0,
0
] | [
"Condition",
"Expr'"
] |
[
"def __lt__(self, VAR_11):...\n",
"return self.rule.__lt__(VAR_11.rule)\n"
] | [
"def __lt__(self, other):...\n",
"return self.rule.__lt__(other.rule)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"@wraps(VAR_8)...\n",
"if g.oidc_id_token is None:\n",
"return self.redirect_to_auth_server(request.url)\n",
"return VAR_8(*VAR_14, **kwargs)\n"
] | [
"@wraps(view_func)...\n",
"if g.oidc_id_token is None:\n",
"return self.redirect_to_auth_server(request.url)\n",
"return view_func(*args, **kwargs)\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_7(VAR_14):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_0.info('Creating admin...')\n",
"VAR_5['username'] = 'admin%s' % VAR_14\n",
"VAR_5['password'] = 'adminpwd'\n",
"FUNC_4([sys.executable, 'cmscontrib/AddAdmin.py', '%(username)s' % VAR_5,\n '-p', '%(password)s' % VAR_5])\n"
] | [
"def initialize_aws(rand):...\n",
"\"\"\"docstring\"\"\"\n",
"logger.info('Creating admin...')\n",
"admin_info['username'] = 'admin%s' % rand\n",
"admin_info['password'] = 'adminpwd'\n",
"sh([sys.executable, 'cmscontrib/AddAdmin.py', '%(username)s' % admin_info,\n '-p', '%(password)s' % admin_info])\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_5(**VAR_6):...\n",
"import sql\n",
"import http.cookies\n",
"VAR_25 = http.cookies.SimpleCookie(os.environ.get('HTTP_COOKIE'))\n",
"VAR_26 = VAR_25.get('uuid')\n",
"VAR_27 = os.environ.get('SCRIPT_NAME')\n",
"sql.delete_old_uuid()\n",
"if VAR_26 is not None:\n",
"sql.update_last_act_user(VAR_26.value)\n",
"print('<meta http-equiv=\"refresh\" content=\"0; url=login.py?ref=%s\">' % VAR_27)\n",
"if sql.get_user_name_by_uuid(VAR_26.value) is None:\n",
"print('<meta http-equiv=\"refresh\" content=\"0; url=login.py?ref=%s\">' % VAR_27)\n"
] | [
"def check_login(**kwargs):...\n",
"import sql\n",
"import http.cookies\n",
"cookie = http.cookies.SimpleCookie(os.environ.get('HTTP_COOKIE'))\n",
"user_uuid = cookie.get('uuid')\n",
"ref = os.environ.get('SCRIPT_NAME')\n",
"sql.delete_old_uuid()\n",
"if user_uuid is not None:\n",
"sql.update_last_act_user(user_uuid.value)\n",
"print('<meta http-equiv=\"refresh\" content=\"0; url=login.py?ref=%s\">' % ref)\n",
"if sql.get_user_name_by_uuid(user_uuid.value) is None:\n",
"print('<meta http-equiv=\"refresh\" content=\"0; url=login.py?ref=%s\">' % ref)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Import'",
"Import'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Condition",
"Expr'"
] |
[
"def FUNC_5():...\n",
"\"\"\"docstring\"\"\"\n",
"user.ensure_group('jupyterhub-admins')\n",
"user.ensure_group('jupyterhub-users')\n",
"VAR_1.info('Granting passwordless sudo to JupyterHub admins...')\n",
"f.write('%jupyterhub-admins ALL = (ALL) NOPASSWD: ALL\\n')\n",
"f.write('Defaults exempt_group = jupyterhub-admins\\n')\n"
] | [
"def ensure_usergroups():...\n",
"\"\"\"docstring\"\"\"\n",
"user.ensure_group('jupyterhub-admins')\n",
"user.ensure_group('jupyterhub-users')\n",
"logger.info('Granting passwordless sudo to JupyterHub admins...')\n",
"f.write('%jupyterhub-admins ALL = (ALL) NOPASSWD: ALL\\n')\n",
"f.write('Defaults exempt_group = jupyterhub-admins\\n')\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"@VAR_0.inclusion_tag('exercise/_user_last.html', takes_context=True)...\n",
"VAR_14 = VAR_1['request'].user\n",
"VAR_16 = FUNC_1(VAR_1)\n",
"if VAR_14.is_authenticated():\n",
"VAR_25 = LearningObjectDisplay.objects.filter(profile=user.userprofile,\n learning_object__status=LearningObject.STATUS.READY,\n learning_object__course_module__course_instance=context['instance']\n ).select_related('learning_object').order_by('-timestamp').first()\n",
"return {'begin': VAR_16.begin(), 'instance': VAR_1['instance']}\n",
"if VAR_25:\n",
"VAR_9, VAR_29, VAR_29, VAR_29 = VAR_16.find(VAR_25.learning_object)\n",
"return {'last': VAR_9, 'last_time': VAR_25.timestamp}\n"
] | [
"@register.inclusion_tag('exercise/_user_last.html', takes_context=True)...\n",
"user = context['request'].user\n",
"points = _prepare_context(context)\n",
"if user.is_authenticated():\n",
"last = LearningObjectDisplay.objects.filter(profile=user.userprofile,\n learning_object__status=LearningObject.STATUS.READY,\n learning_object__course_module__course_instance=context['instance']\n ).select_related('learning_object').order_by('-timestamp').first()\n",
"return {'begin': points.begin(), 'instance': context['instance']}\n",
"if last:\n",
"entry, _, _, _ = points.find(last.learning_object)\n",
"return {'last': entry, 'last_time': last.timestamp}\n"
] | [
0,
0,
0,
4,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Condition",
"Assign'",
"Return'"
] |
[
"def FUNC_32(VAR_19):...\n",
"return dict((expr, vimsupport.VimExpressionToPythonType(expr)) for expr in\n VAR_19)\n"
] | [
"def BuildExtraConfData(extra_conf_vim_data):...\n",
"return dict((expr, vimsupport.VimExpressionToPythonType(expr)) for expr in\n extra_conf_vim_data)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_7(self):...\n",
"return {}\n"
] | [
"def Response(self):...\n",
"return {}\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_8(self):...\n",
"return 'try to login'\n"
] | [
"def describe(self):...\n",
"return 'try to login'\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_21(VAR_18, VAR_29, VAR_30=60):...\n",
"VAR_50 = re.compile(\n 'Compiling\\\\.\\\\.\\\\.|Evaluating\\\\.\\\\.\\\\.|Scoring\\\\.\\\\.\\\\.|Evaluated')\n",
"VAR_51 = re.compile('Compilation failed|Evaluated \\\\(|Scored \\\\(')\n",
"VAR_34 = FUNC_0()\n",
"VAR_52 = 0.1\n",
"while VAR_30 > 0:\n",
"VAR_30 -= VAR_52\n",
"VAR_49 = AWSSubmissionViewRequest(VAR_34, VAR_29, base_url=AWS_BASE_URL)\n",
"VAR_49.execute()\n",
"VAR_63 = VAR_49.get_submission_info()\n",
"VAR_64 = VAR_63['status']\n",
"if VAR_51.search(VAR_64):\n",
"return VAR_63\n",
"if VAR_50.search(VAR_64):\n",
"time.sleep(VAR_52)\n"
] | [
"def get_evaluation_result(contest_id, submission_id, timeout=60):...\n",
"WAITING_STATUSES = re.compile(\n 'Compiling\\\\.\\\\.\\\\.|Evaluating\\\\.\\\\.\\\\.|Scoring\\\\.\\\\.\\\\.|Evaluated')\n",
"COMPLETED_STATUS = re.compile('Compilation failed|Evaluated \\\\(|Scored \\\\(')\n",
"browser = get_aws_browser()\n",
"sleep_interval = 0.1\n",
"while timeout > 0:\n",
"timeout -= sleep_interval\n",
"sr = AWSSubmissionViewRequest(browser, submission_id, base_url=AWS_BASE_URL)\n",
"sr.execute()\n",
"result = sr.get_submission_info()\n",
"status = result['status']\n",
"if COMPLETED_STATUS.search(status):\n",
"return result\n",
"if WAITING_STATUSES.search(status):\n",
"time.sleep(sleep_interval)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"AugAssign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Condition",
"Expr'"
] |
[
"def FUNC_1(VAR_0):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_16 = os.path.basename(VAR_0)\n",
"print('Fetching %s...' % VAR_16)\n",
"FUNC_0(VAR_0 + '.asc')\n",
"FUNC_0(VAR_0)\n",
"FUNC_0(VAR_0 + '.sha256')\n",
"FUNC_0(VAR_0 + '.asc.sha256')\n",
"print('Verifying %s...' % VAR_16)\n",
"os.system('shasum -c %s.sha256' % VAR_16)\n",
"os.system('shasum -c %s.asc.sha256' % VAR_16)\n",
"os.system('gpg --verify %s.asc %s' % (VAR_16, VAR_16))\n",
"os.system('keybase verify %s.asc' % VAR_16)\n"
] | [
"def fetch(url):...\n",
"\"\"\"docstring\"\"\"\n",
"base = os.path.basename(url)\n",
"print('Fetching %s...' % base)\n",
"fetch_file(url + '.asc')\n",
"fetch_file(url)\n",
"fetch_file(url + '.sha256')\n",
"fetch_file(url + '.asc.sha256')\n",
"print('Verifying %s...' % base)\n",
"os.system('shasum -c %s.sha256' % base)\n",
"os.system('shasum -c %s.asc.sha256' % base)\n",
"os.system('gpg --verify %s.asc %s' % (base, base))\n",
"os.system('keybase verify %s.asc' % base)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
2,
2,
2,
2
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.