lines
sequencelengths 1
444
| raw_lines
sequencelengths 1
444
| label
sequencelengths 1
444
| type
sequencelengths 1
444
|
|---|---|---|---|
[
"@receiver(VAR_5, **decorator_kwargs)...\n",
"if settings.SUSPEND_SIGNALS:\n",
"return\n",
"return VAR_17(VAR_23, **kwargs)\n"
] | [
"@receiver(signal, **decorator_kwargs)...\n",
"if settings.SUSPEND_SIGNALS:\n",
"return\n",
"return func(sender, **kwargs)\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_10(self, VAR_11):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_21 = FUNC_6(VAR_8=self.request.url)\n",
"VAR_22 = helpers.get_user_email()\n",
"if not VAR_22:\n",
"self.redirect(VAR_21)\n",
"VAR_23 = db_config.get_value('contact_string')\n",
"return\n",
"VAR_24 = {'message': VAR_11, 'user_email': helpers.get_user_email(),\n 'login_url': VAR_21, 'switch_account_url': VAR_21, 'logout_url': FUNC_7\n (VAR_8=self.request.url), 'contact_string': VAR_23}\n",
"self.render('error-403.html', VAR_24, 403)\n"
] | [
"def render_forbidden(self, message):...\n",
"\"\"\"docstring\"\"\"\n",
"login_url = make_login_url(dest_url=self.request.url)\n",
"user_email = helpers.get_user_email()\n",
"if not user_email:\n",
"self.redirect(login_url)\n",
"contact_string = db_config.get_value('contact_string')\n",
"return\n",
"template_values = {'message': message, 'user_email': helpers.get_user_email\n (), 'login_url': login_url, 'switch_account_url': login_url,\n 'logout_url': make_logout_url(dest_url=self.request.url),\n 'contact_string': contact_string}\n",
"self.render('error-403.html', template_values, 403)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Return'",
"Assign'",
"Expr'"
] |
[
"def FUNC_0(self, VAR_2, VAR_3, VAR_4):...\n",
"if not VAR_4:\n",
"return\n",
"if validate_hash(VAR_4):\n",
"if validate_url(VAR_4):\n",
"VAR_21 = VirusTotalAPI().hash_fetch(VAR_4)\n",
"VAR_2['errors'].append('Error retrieving file hash: %s' % e)\n",
"VAR_18 = Files.create(VAR_3, VAR_4, VAR_21)\n",
"VAR_2['data'].append({'type': 'url', 'data': VAR_4})\n",
"VAR_2['errors'].append(\"'%s' was neither a valid hash or url\" % VAR_4)\n",
"return\n",
"VAR_2['data'].append({'type': 'file', 'data': VAR_18})\n",
"return\n",
"return\n"
] | [
"def _handle_string(self, submit, tmppath, line):...\n",
"if not line:\n",
"return\n",
"if validate_hash(line):\n",
"if validate_url(line):\n",
"filedata = VirusTotalAPI().hash_fetch(line)\n",
"submit['errors'].append('Error retrieving file hash: %s' % e)\n",
"filepath = Files.create(tmppath, line, filedata)\n",
"submit['data'].append({'type': 'url', 'data': line})\n",
"submit['errors'].append(\"'%s' was neither a valid hash or url\" % line)\n",
"return\n",
"submit['data'].append({'type': 'file', 'data': filepath})\n",
"return\n",
"return\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Condition",
"Condition",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Return'",
"Expr'",
"Return'",
"Return'"
] |
[
"def FUNC_2(self, VAR_5):...\n",
""
] | [
"def _on_list_scroll(self, event):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_6(self):...\n",
"self.client.login(username=self.tester.username, password='password')\n",
"VAR_1 = self.client.post(self.many_comments_url, {'comment': 'new comment',\n 'run': '99999998,1009900'})\n",
"self.assertJSONEqual(str(VAR_1.content, encoding=settings.DEFAULT_CHARSET),\n {'rc': 1, 'response': 'No caserun found.'})\n"
] | [
"def test_refuse_if_passed_case_run_pks_not_exist(self):...\n",
"self.client.login(username=self.tester.username, password='password')\n",
"response = self.client.post(self.many_comments_url, {'comment':\n 'new comment', 'run': '99999998,1009900'})\n",
"self.assertJSONEqual(str(response.content, encoding=settings.\n DEFAULT_CHARSET), {'rc': 1, 'response': 'No caserun found.'})\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"def FUNC_16(VAR_1):...\n",
"async def FUNC_15(VAR_3):...\n",
"VAR_19 = await VAR_1(VAR_3, VAR_4)\n",
"return VAR_19\n"
] | [
"def decorator(func):...\n",
"async def ret(request):...\n",
"out = await func(request, base)\n",
"return out\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"AsyncFunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_7(self):...\n",
"return {}\n"
] | [
"def Response(self):...\n",
"return {}\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_9(self):...\n",
"self._hosts_cache = None\n",
"for VAR_12 in self.parent_groups:\n",
"VAR_12.clear_hosts_cache()\n"
] | [
"def clear_hosts_cache(self):...\n",
"self._hosts_cache = None\n",
"for g in self.parent_groups:\n",
"g.clear_hosts_cache()\n"
] | [
0,
0,
1,
1
] | [
"FunctionDef'",
"Assign'",
"For",
"Expr'"
] |
[
"def FUNC_1(self):...\n",
"self.attachNeighbours()\n",
"self.identifyTurning()\n",
"self.genConnections()\n"
] | [
"def resetToOriginal(self):...\n",
"self.attachNeighbours()\n",
"self.identifyTurning()\n",
"self.genConnections()\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_2(self, VAR_1, VAR_2, *VAR_3, **VAR_4):...\n",
"self.handled_resp = VAR_1\n",
"self.handled_remote = VAR_2\n",
"self.handled_args = VAR_3\n",
"self.handled_kwargs = VAR_4\n",
"return 'TEST'\n"
] | [
"def handler(self, resp, remote, *args, **kwargs):...\n",
"self.handled_resp = resp\n",
"self.handled_remote = remote\n",
"self.handled_args = args\n",
"self.handled_kwargs = kwargs\n",
"return 'TEST'\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"\"\"\"\nCreated on 1 Feb 2018\n\n@author: Teodor Gherasim Nistor\n\"\"\"\n",
"from beamr.debug import debug, warn\n",
"from beamr.lexers import docLexer, slideLexer\n",
"from beamr.parsers import docParser, slideParser\n",
"from beamr.interpreters import Config, VerbatimEnv\n",
"def __init__(self, VAR_0, VAR_1='', VAR_2='', VAR_3=''):...\n",
"self.children = VAR_0\n",
"self.before = VAR_1\n",
"self.after = VAR_2\n",
"self.inter = VAR_3\n",
"def __str__(self):...\n",
"VAR_26 = self.before\n",
"for c in self.children:\n",
"VAR_26 += str(c) + self.inter\n",
"VAR_26 += self.after\n",
"return VAR_26\n"
] | [
"\"\"\"\nCreated on 1 Feb 2018\n\n@author: Teodor Gherasim Nistor\n\"\"\"\n",
"from beamr.debug import debug, warn\n",
"from beamr.lexers import docLexer, slideLexer\n",
"from beamr.parsers import docParser, slideParser\n",
"from beamr.interpreters import Config, VerbatimEnv\n",
"def __init__(self, children, before='', after='', inter=''):...\n",
"self.children = children\n",
"self.before = before\n",
"self.after = after\n",
"self.inter = inter\n",
"def __str__(self):...\n",
"s = self.before\n",
"for c in self.children:\n",
"s += str(c) + self.inter\n",
"s += self.after\n",
"return s\n"
] | [
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"FunctionDef'",
"Assign'",
"For",
"AugAssign'",
"AugAssign'",
"Return'"
] |
[
"def __init__(self, VAR_1, VAR_7):...\n",
"self.message = VAR_1\n",
"self.user = VAR_7\n",
"self.image_handler = ImageHandler\n"
] | [
"def __init__(self, message, user):...\n",
"self.message = message\n",
"self.user = user\n",
"self.image_handler = ImageHandler\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_6(self):...\n",
"\"\"\"docstring\"\"\"\n",
"if self.eng is not None and self.backend == 'Simulator' or self.backend == 'IBMBackend':\n",
"pq.ops.All(pq.ops.Measure) | self.reg\n"
] | [
"def _deallocate(self):...\n",
"\"\"\"docstring\"\"\"\n",
"if self.eng is not None and self.backend == 'Simulator' or self.backend == 'IBMBackend':\n",
"pq.ops.All(pq.ops.Measure) | self.reg\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Expr'"
] |
[
"def FUNC_2(VAR_14=None, VAR_15=None, VAR_16=None, VAR_17=None, VAR_18=None,...\n",
"if VAR_16 is None:\n",
"VAR_16 = time.strftime('%Y-%m-%d %H:%M:%S')\n",
"VAR_32 = 'string'\n",
"VAR_33 = (VAR_14, VAR_15, VAR_16, VAR_17, VAR_18, VAR_19, VAR_20, VAR_21,\n VAR_22, VAR_23, VAR_24, VAR_25, VAR_26)\n",
"VAR_13.execute(VAR_32, VAR_33)\n",
"VAR_12.commit()\n",
"return VAR_13.lastrowid\n"
] | [
"def add_history_record(username=None, action=None, sql_time=None, address=...\n",
"if sql_time is None:\n",
"sql_time = time.strftime('%Y-%m-%d %H:%M:%S')\n",
"sql = (\n 'INSERT INTO history (username, action, sql_time, address, comment_or_message, recipient_username, recipient_address, amount, hash, comment_id, notes, reddit_time, comment_text) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'\n )\n",
"val = (username, action, sql_time, address, comment_or_message,\n recipient_username, recipient_address, amount, hash, comment_id, notes,\n reddit_time, comment_text)\n",
"mycursor.execute(sql, val)\n",
"mydb.commit()\n",
"return mycursor.lastrowid\n"
] | [
0,
4,
4,
4,
4,
4,
4,
4
] | [
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Return'"
] |
[
"def __init__(self, VAR_0, VAR_1, VAR_2=[], VAR_3=[]):...\n",
"self.realpath = VAR_0\n",
"self.vpath = VAR_1\n",
"self.uread = VAR_2\n",
"self.uwrite = VAR_3\n",
"self.nodes = {}\n"
] | [
"def __init__(self, realpath, vpath, uread=[], uwrite=[]):...\n",
"self.realpath = realpath\n",
"self.vpath = vpath\n",
"self.uread = uread\n",
"self.uwrite = uwrite\n",
"self.nodes = {}\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_9(self):...\n",
"\"\"\"docstring\"\"\"\n",
"import soscollector.clusters\n",
"VAR_4 = soscollector.clusters\n",
"VAR_17 = {}\n",
"VAR_18 = self._load_modules(VAR_4, 'clusters')\n",
"for VAR_9 in VAR_18:\n",
"VAR_17[VAR_9[0]] = VAR_9[1](self)\n",
"return VAR_17\n"
] | [
"def _load_clusters(self):...\n",
"\"\"\"docstring\"\"\"\n",
"import soscollector.clusters\n",
"package = soscollector.clusters\n",
"supported_clusters = {}\n",
"clusters = self._load_modules(package, 'clusters')\n",
"for cluster in clusters:\n",
"supported_clusters[cluster[0]] = cluster[1](self)\n",
"return supported_clusters\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Import'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Return'"
] |
[
"def __init__(self, VAR_18, VAR_35=200, **VAR_16):...\n",
"CLASS_17.__init__(self, VAR_18, VAR_35=length, VAR_36=errors.NO_TITLE,\n VAR_37=errors.TITLE_TOO_LONG, **kw)\n"
] | [
"def __init__(self, item, length=200, **kw):...\n",
"VLength.__init__(self, item, length=length, empty_error=errors.NO_TITLE,\n length_error=errors.TITLE_TOO_LONG, **kw)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_15(VAR_1, VAR_2, VAR_13, VAR_14, VAR_15):...\n",
"\"\"\"docstring\"\"\"\n",
"flash('Authorization with remote service failed.')\n",
"return redirect('/')\n"
] | [
"def oauth2_handle_error(remote, resp, error_code, error_uri, error_description...\n",
"\"\"\"docstring\"\"\"\n",
"flash('Authorization with remote service failed.')\n",
"return redirect('/')\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Return'"
] |
[
"def FUNC_12(self):...\n",
"self.compilation_ok('string')\n",
"self.representation_is('string')\n"
] | [
"def test_rfc5228_extended(self):...\n",
"self.compilation_ok(\n \"\"\"\n#\n# Example Sieve Filter\n# Declare any optional features or extension used by the script\n#\nrequire [\"fileinto\"];\n\n#\n# Handle messages from known mailing lists\n# Move messages from IETF filter discussion list to filter mailbox\n#\nif header :is \"Sender\" \"[email protected]\"\n {\n fileinto \"filter\"; # move to \"filter\" mailbox\n }\n#\n# Keep all messages to or from people in my company\n#\nelsif address :DOMAIN :is [\"From\", \"To\"] \"example.com\"\n {\n keep; # keep in \"In\" mailbox\n }\n\n#\n# Try and catch unsolicited email. If a message is not to me,\n# or it contains a subject known to be spam, file it away.\n#\nelsif anyof (NOT address :all :contains\n [\"To\", \"Cc\", \"Bcc\"] \"[email protected]\",\n header :matches \"subject\"\n [\"*make*money*fast*\", \"*university*dipl*mas*\"])\n {\n fileinto \"spam\"; # move to \"spam\" mailbox\n }\nelse\n {\n # Move all other (non-company) mail to \"personal\"\n # mailbox.\n fileinto \"personal\";\n }\n\"\"\"\n )\n",
"self.representation_is(\n \"\"\"\nrequire (type: control)\n [\"fileinto\"]\nif (type: control)\n header (type: test)\n :is\n \"Sender\"\n \"[email protected]\"\n fileinto (type: action)\n \"filter\"\nelsif (type: control)\n address (type: test)\n :DOMAIN\n :is\n [\"From\",\"To\"]\n \"example.com\"\n keep (type: action)\nelsif (type: control)\n anyof (type: test)\n not (type: test)\n address (type: test)\n :all\n :contains\n [\"To\",\"Cc\",\"Bcc\"]\n \"[email protected]\"\n header (type: test)\n :matches\n \"subject\"\n [\"*make*money*fast*\",\"*university*dipl*mas*\"]\n fileinto (type: action)\n \"spam\"\nelse (type: control)\n fileinto (type: action)\n \"personal\\\"\n\"\"\"\n )\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'"
] |
[
"def FUNC_3(self):...\n",
"FUNC_0()\n",
"import yaml\n",
"self.app_id = yaml.load(open(os.path.join(self.base_dir, 'app.yaml'), 'r'))[\n 'application']\n",
"logging.debug('Instance app id: %s' % self.app_id)\n",
"assert self.app_id\n"
] | [
"def install_prerequisites(self):...\n",
"_load_modules()\n",
"import yaml\n",
"self.app_id = yaml.load(open(os.path.join(self.base_dir, 'app.yaml'), 'r'))[\n 'application']\n",
"logging.debug('Instance app id: %s' % self.app_id)\n",
"assert self.app_id\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Import'",
"Assign'",
"Expr'",
"Assert'"
] |
[
"def FUNC_4(self, VAR_4):...\n",
"self.result = VAR_4\n"
] | [
"def set_result(self, result):...\n",
"self.result = result\n"
] | [
0,
0
] | [
"FunctionDef'",
"Assign'"
] |
[
"def FUNC_4(VAR_6, VAR_7, VAR_8):...\n",
"\"\"\"docstring\"\"\"\n",
"return VAR_6 and ('%s:%s' % (VAR_8 or '', VAR_7) in VAR_6.user_roles or \n ':%s' % VAR_7 in VAR_6.user_roles)\n"
] | [
"def check_user_role(auth, role, cc):...\n",
"\"\"\"docstring\"\"\"\n",
"return auth and ('%s:%s' % (cc or '', role) in auth.user_roles or ':%s' %\n role in auth.user_roles)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def __init__(self, VAR_2=2, VAR_3=10, VAR_4=False):...\n",
"self.idleTimeout = VAR_2\n",
"self.timeout = VAR_3\n",
"self.insecure = VAR_4\n"
] | [
"def __init__(self, idleTimeout=2, timeout=10, insecure=False):...\n",
"self.idleTimeout = idleTimeout\n",
"self.timeout = timeout\n",
"self.insecure = insecure\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_21(VAR_16):...\n",
"return (VAR_16.input, VAR_16.dynamic_input) if VAR_4 else (VAR_16.output,\n VAR_16.dynamic_output)\n"
] | [
"def get_io(rule):...\n",
"return (rule.input, rule.dynamic_input) if input else (rule.output, rule.\n dynamic_output)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_2():...\n",
"VAR_9 = FUNC_0()\n",
"VAR_10 = VAR_9.cursor()\n",
"VAR_10.execute(VAR_7)\n",
"VAR_9.commit()\n",
"VAR_2.info('successfully created karma db for the first time')\n"
] | [
"def create_karma_table():...\n",
"db = db_connect()\n",
"cursor = db.cursor()\n",
"cursor.execute(PEOPLE_TABLE)\n",
"db.commit()\n",
"logger.info('successfully created karma db for the first time')\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_6(self, VAR_7):...\n",
"VAR_8 = self.content\n",
"while VAR_8:\n",
"yield VAR_8[:VAR_7]\n",
"VAR_8 = VAR_8[VAR_7:]\n"
] | [
"def iter_content(self, chunk_size):...\n",
"c = self.content\n",
"while c:\n",
"yield c[:chunk_size]\n",
"c = c[chunk_size:]\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Expr'",
"Assign'"
] |
[
"async def FUNC_2(self, *VAR_12, **VAR_13):...\n",
"VAR_11 = VAR_13.pop('content', None)\n",
"if VAR_11 is not None:\n",
"await self.set_content(VAR_11)\n",
"return await super().save(*VAR_12, **kwargs)\n"
] | [
"async def save(self, *args, **kwargs):...\n",
"content = kwargs.pop('content', None)\n",
"if content is not None:\n",
"await self.set_content(content)\n",
"return await super().save(*args, **kwargs)\n"
] | [
0,
0,
0,
0,
0
] | [
"AsyncFunctionDef'",
"Assign'",
"Condition",
"Expr'",
"Return'"
] |
[
"def FUNC_3(self):...\n",
"self.driver._eql_execute = self.mox.CreateMock(self.driver._eql_execute)\n",
"VAR_1 = {'name': self.volume_name, 'size': 1}\n",
"self.driver._eql_execute('volume', 'select', VAR_1['name'], 'show')\n",
"self.driver._eql_execute('volume', 'select', VAR_1['name'], 'offline')\n",
"self.driver._eql_execute('volume', 'delete', VAR_1['name'])\n",
"self.mox.ReplayAll()\n",
"self.driver.delete_volume(VAR_1)\n"
] | [
"def test_delete_volume(self):...\n",
"self.driver._eql_execute = self.mox.CreateMock(self.driver._eql_execute)\n",
"volume = {'name': self.volume_name, 'size': 1}\n",
"self.driver._eql_execute('volume', 'select', volume['name'], 'show')\n",
"self.driver._eql_execute('volume', 'select', volume['name'], 'offline')\n",
"self.driver._eql_execute('volume', 'delete', volume['name'])\n",
"self.mox.ReplayAll()\n",
"self.driver.delete_volume(volume)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_9(self, VAR_10=True):...\n",
"return self.aq_parent.breadcrumbs_obj_path(VAR_10)\n"
] | [
"def breadcrumbs_obj_path(self, portalMaster=True):...\n",
"return self.aq_parent.breadcrumbs_obj_path(portalMaster)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_19(self):...\n",
"self._test_strtype('blob', None, 4000)\n"
] | [
"def test_large_null_blob(self):...\n",
"self._test_strtype('blob', None, 4000)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"@classmethod...\n",
"\"\"\"docstring\"\"\"\n",
"return FUNC_1(VAR_3, VAR_7, VAR_4)\n"
] | [
"@classmethod...\n",
"\"\"\"docstring\"\"\"\n",
"return create_resource_from_dict(d, cls, full_clean)\n"
] | [
0,
0,
0
] | [
"Condition",
"Docstring",
"Return'"
] |
[
"def FUNC_8(self):...\n",
"self.driver._eql_execute = self.mox.CreateMock(self.driver._eql_execute)\n",
"VAR_5 = {'id': 'fake_uuid'}\n",
"VAR_1 = {'name': self.volume_name}\n",
"VAR_6 = self.configuration.volume_name_template % VAR_5['id']\n",
"self.driver._eql_execute('volume', 'select', VAR_6, 'clone', VAR_1['name']\n ).AndReturn(['iSCSI target name is %s.' % self.fake_iqn])\n",
"self.mox.ReplayAll()\n",
"VAR_2 = self.driver.create_cloned_volume(VAR_1, VAR_5)\n",
"self.assertEqual(VAR_2, self._model_update)\n"
] | [
"def test_create_cloned_volume(self):...\n",
"self.driver._eql_execute = self.mox.CreateMock(self.driver._eql_execute)\n",
"src_vref = {'id': 'fake_uuid'}\n",
"volume = {'name': self.volume_name}\n",
"src_volume_name = self.configuration.volume_name_template % src_vref['id']\n",
"self.driver._eql_execute('volume', 'select', src_volume_name, 'clone',\n volume['name']).AndReturn(['iSCSI target name is %s.' % self.fake_iqn])\n",
"self.mox.ReplayAll()\n",
"model_update = self.driver.create_cloned_volume(volume, src_vref)\n",
"self.assertEqual(model_update, self._model_update)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"\"\"\"\nUnit tests for the Deis api app.\n\nRun the tests with \"./manage.py test api\\\"\n\"\"\"\n",
"from __future__ import unicode_literals\n",
"import json\n",
"import mock\n",
"import requests\n",
"from django.test import TransactionTestCase\n",
"from api.models import Build\n",
"def FUNC_0(*VAR_0, **VAR_1):...\n",
"VAR_2 = requests.Response()\n",
"VAR_2.status_code = 200\n",
"VAR_2._content_consumed = True\n",
"return VAR_2\n"
] | [
"\"\"\"\nUnit tests for the Deis api app.\n\nRun the tests with \"./manage.py test api\\\"\n\"\"\"\n",
"from __future__ import unicode_literals\n",
"import json\n",
"import mock\n",
"import requests\n",
"from django.test import TransactionTestCase\n",
"from api.models import Build\n",
"def mock_import_repository_task(*args, **kwargs):...\n",
"resp = requests.Response()\n",
"resp.status_code = 200\n",
"resp._content_consumed = True\n",
"return resp\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"ImportFrom'",
"Import'",
"Import'",
"Import'",
"ImportFrom'",
"ImportFrom'",
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_4(VAR_5, VAR_6='csrf_token', VAR_7=VAR_1, VAR_8=True):...\n",
"VAR_10 = VAR_5.params.get(VAR_6, VAR_5.headers.get(VAR_7))\n",
"if VAR_10 != VAR_5.session.get_csrf_token():\n",
"if VAR_8:\n",
"return True\n",
"return False\n"
] | [
"def check_csrf_token(request, token='csrf_token', header=HEADER_NAME,...\n",
"supplied_token = request.params.get(token, request.headers.get(header))\n",
"if supplied_token != request.session.get_csrf_token():\n",
"if raises:\n",
"return True\n",
"return False\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_8(self, VAR_9, VAR_10=None, VAR_11=None):...\n",
"get_and_check_project(VAR_9, VAR_11)\n",
"VAR_28 = self.queryset.get(VAR_10=pk, VAR_1=project_pk)\n",
"VAR_26 = CLASS_1(VAR_28)\n",
"return Response(VAR_26.data)\n"
] | [
"def retrieve(self, request, pk=None, project_pk=None):...\n",
"get_and_check_project(request, project_pk)\n",
"task = self.queryset.get(pk=pk, project=project_pk)\n",
"serializer = TaskSerializer(task)\n",
"return Response(serializer.data)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_0(VAR_2):...\n",
"\"\"\"docstring\"\"\"\n",
"return u'̶'.join(VAR_2) + u'̶'\n"
] | [
"def strike(text):...\n",
"\"\"\"docstring\"\"\"\n",
"return u'̶'.join(text) + u'̶'\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def FUNC_3(self, *VAR_2):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_1 = self.options\n",
"VAR_3 = 'http://{host}:{port}/{path}'.format(host=options.host, port=\n options.port, path=COMMANDS[options.prog])\n",
"log.logger.error('Daemon not available: %s', e)\n",
"VAR_4 = json.dumps(VAR_2[1:])\n",
"log.logger.exception(e)\n",
"log.logger.debug(\"\"\"Request to %s:\n%s\"\"\", VAR_3, VAR_4)\n",
"VAR_5 = urllib2.urlopen(VAR_3, VAR_4)\n",
"for i in ijson.items(VAR_5, 'item'):\n",
"yield from_json(i)\n"
] | [
"def executer(self, *args):...\n",
"\"\"\"docstring\"\"\"\n",
"options = self.options\n",
"url = 'http://{host}:{port}/{path}'.format(host=options.host, port=options.\n port, path=COMMANDS[options.prog])\n",
"log.logger.error('Daemon not available: %s', e)\n",
"request = json.dumps(args[1:])\n",
"log.logger.exception(e)\n",
"log.logger.debug(\"\"\"Request to %s:\n%s\"\"\", url, request)\n",
"response = urllib2.urlopen(url, request)\n",
"for i in ijson.items(response, 'item'):\n",
"yield from_json(i)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"For",
"Expr'"
] |
[
"def FUNC_9(VAR_13, VAR_14, VAR_15):...\n",
"if VAR_15 == 0:\n",
"VAR_15 = 'INFO : '\n",
"if VAR_15 == 1:\n",
"VAR_42 = 'INFO : '\n",
"VAR_15 = '! WARNING : '\n",
"VAR_15 = '!! ERROR : '\n",
"VAR_27 = datetime.now()\n",
"VAR_42 = '**WARNING : **'\n",
"VAR_42 = '__**ERROR : **__'\n",
"VAR_28 = VAR_27.strftime('%Y/%m/%d %H:%M:%S')\n",
"VAR_29 = open(constants.Paths.logsFile, 'a')\n",
"VAR_30 = str(VAR_15) + str(VAR_28) + ' -' + str(VAR_13) + ' : ' + str(VAR_14)\n",
"VAR_29.write(VAR_30 + '\\n')\n",
"VAR_31 = str(VAR_42) + str(VAR_28) + ' -' + str(VAR_13) + ' : ' + str(VAR_14)\n",
"VAR_29.close()\n",
"return VAR_31\n"
] | [
"def Log(user, message, logLevel):...\n",
"if logLevel == 0:\n",
"logLevel = 'INFO : '\n",
"if logLevel == 1:\n",
"discordLogLevel = 'INFO : '\n",
"logLevel = '! WARNING : '\n",
"logLevel = '!! ERROR : '\n",
"i = datetime.now()\n",
"discordLogLevel = '**WARNING : **'\n",
"discordLogLevel = '__**ERROR : **__'\n",
"date = i.strftime('%Y/%m/%d %H:%M:%S')\n",
"LogFile = open(constants.Paths.logsFile, 'a')\n",
"fileOutput = str(logLevel) + str(date) + ' -' + str(user) + ' : ' + str(message\n )\n",
"LogFile.write(fileOutput + '\\n')\n",
"discordOutput = str(discordLogLevel) + str(date) + ' -' + str(user\n ) + ' : ' + str(message)\n",
"LogFile.close()\n",
"return discordOutput\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Return'"
] |
[
"def FUNC_4(self, VAR_9):...\n",
"if not users.is_current_user_admin():\n",
"self.response.set_status(403)\n",
"VAR_0[VAR_9](self).post()\n",
"return\n"
] | [
"def post(self, command):...\n",
"if not users.is_current_user_admin():\n",
"self.response.set_status(403)\n",
"commands[command](self).post()\n",
"return\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Expr'",
"Expr'",
"Return'"
] |
[
"@VAR_0.route('/')...\n",
""
] | [
"@app.route('/')...\n",
""
] | [
0,
0
] | [
"Condition",
"Condition"
] |
[
"def FUNC_6(self, VAR_14=None, VAR_15=False, VAR_16=False):...\n",
"self.write('\\n')\n",
"self.read_until(VAR_12=True)\n",
"if VAR_15:\n",
"self.write('export PS1=\"DrSEUs# \"\\n')\n",
"self.command('mkdir ~/.ssh')\n",
"self.read_until('export PS1=\"DrSEUs# \"')\n",
"self.command('touch ~/.ssh/authorized_keys')\n",
"self.prompt = 'DrSEUs# '\n",
"self.command('echo \"ssh-rsa ' + self.rsakey.get_base64() +\n '\" > ~/.ssh/authorized_keys')\n",
"self.read_until()\n",
"if VAR_14 is None:\n",
"VAR_7 = 10\n",
"self.command('ip addr add ' + VAR_14 + '/24 dev eth0')\n",
"for attempt in range(VAR_7):\n",
"self.command('ip link set eth0 up')\n",
"for VAR_26 in self.command('ip addr show').split('\\n'):\n",
"if VAR_16:\n",
"self.command('ip addr show')\n",
"VAR_26 = VAR_26.strip().split()\n",
"if VAR_14 is not None:\n",
"self.ip_address = '127.0.0.1'\n",
"self.ip_address = VAR_14\n",
"if len(VAR_26) > 0 and VAR_26[0] == 'inet':\n",
"VAR_27 = VAR_26[1].split('/')[0]\n",
"if VAR_27 != '127.0.0.1':\n",
"VAR_14 = VAR_27\n"
] | [
"def do_login(self, ip_address=None, change_prompt=False, simics=False):...\n",
"self.write('\\n')\n",
"self.read_until(boot=True)\n",
"if change_prompt:\n",
"self.write('export PS1=\"DrSEUs# \"\\n')\n",
"self.command('mkdir ~/.ssh')\n",
"self.read_until('export PS1=\"DrSEUs# \"')\n",
"self.command('touch ~/.ssh/authorized_keys')\n",
"self.prompt = 'DrSEUs# '\n",
"self.command('echo \"ssh-rsa ' + self.rsakey.get_base64() +\n '\" > ~/.ssh/authorized_keys')\n",
"self.read_until()\n",
"if ip_address is None:\n",
"attempts = 10\n",
"self.command('ip addr add ' + ip_address + '/24 dev eth0')\n",
"for attempt in range(attempts):\n",
"self.command('ip link set eth0 up')\n",
"for line in self.command('ip addr show').split('\\n'):\n",
"if simics:\n",
"self.command('ip addr show')\n",
"line = line.strip().split()\n",
"if ip_address is not None:\n",
"self.ip_address = '127.0.0.1'\n",
"self.ip_address = ip_address\n",
"if len(line) > 0 and line[0] == 'inet':\n",
"addr = line[1].split('/')[0]\n",
"if addr != '127.0.0.1':\n",
"ip_address = addr\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
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Condition",
"Assign'",
"Expr'",
"For",
"Expr'",
"For",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'"
] |
[
"def FUNC_6():...\n",
"if not request.method in VAR_0:\n",
"return True\n",
"if not request.environ.get('AUTH_TYPE') == 'cookie':\n",
"return True\n",
"if config.get('skip_authentication'):\n",
"return True\n",
"if request.environ.get('HTTP_REFERER'):\n",
"VAR_7 = urlparse(request.environ.get('HTTP_REFERER'))\n",
"if request.method == 'GET' and FUNC_4():\n",
"VAR_8 = VAR_7.hostname\n",
"return True\n",
"return False\n",
"if VAR_7.port:\n",
"VAR_8 += ':' + str(VAR_7.port)\n",
"if VAR_8.endswith(request.environ['adhocracy.domain']):\n",
"if request.method != 'GET':\n",
"return True\n"
] | [
"def check():...\n",
"if not request.method in methods:\n",
"return True\n",
"if not request.environ.get('AUTH_TYPE') == 'cookie':\n",
"return True\n",
"if config.get('skip_authentication'):\n",
"return True\n",
"if request.environ.get('HTTP_REFERER'):\n",
"ref_url = urlparse(request.environ.get('HTTP_REFERER'))\n",
"if request.method == 'GET' and has_token():\n",
"ref_host = ref_url.hostname\n",
"return True\n",
"return False\n",
"if ref_url.port:\n",
"ref_host += ':' + str(ref_url.port)\n",
"if ref_host.endswith(request.environ['adhocracy.domain']):\n",
"if request.method != 'GET':\n",
"return True\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
5,
0,
0,
0,
0,
0,
0,
5,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Condition",
"Return'",
"Condition",
"Return'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Return'",
"Condition",
"AugAssign'",
"Condition",
"Condition",
"Return'"
] |
[
"def __init__(self, VAR_6, VAR_7=None, VAR_8=None, VAR_30=None, VAR_31=utils...\n",
"if VAR_9:\n",
"self.nsx_api_managers = VAR_9.nsx_api_managers or []\n",
"self.nsx_api_managers = VAR_30 or []\n",
"self.max_attempts = VAR_9.max_attempts\n",
"self.max_attempts = VAR_31\n",
"VAR_7 = VAR_7 or VAR_32\n",
"if VAR_7 and VAR_32 not in VAR_7:\n",
"if VAR_7.startswith('http'):\n",
"self.max_attempts = VAR_31\n",
"VAR_7 += '/' + VAR_32\n",
"VAR_7 = '%s/%s' % (VAR_32, VAR_7 or '')\n",
"super(CLASS_2, self).__init__(VAR_6, VAR_7=url_prefix, VAR_8=\n default_headers, VAR_9=client_obj)\n"
] | [
"def __init__(self, connection, url_prefix=None, default_headers=None,...\n",
"if client_obj:\n",
"self.nsx_api_managers = client_obj.nsx_api_managers or []\n",
"self.nsx_api_managers = nsx_api_managers or []\n",
"self.max_attempts = client_obj.max_attempts\n",
"self.max_attempts = max_attempts\n",
"url_prefix = url_prefix or url_path_base\n",
"if url_prefix and url_path_base not in url_prefix:\n",
"if url_prefix.startswith('http'):\n",
"self.max_attempts = max_attempts\n",
"url_prefix += '/' + url_path_base\n",
"url_prefix = '%s/%s' % (url_path_base, url_prefix or '')\n",
"super(NSX3Client, self).__init__(connection, url_prefix=url_prefix,\n default_headers=default_headers, client_obj=client_obj)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"Assign'",
"AugAssign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_11(self):...\n",
"self.run_test_case(self.scenario.create_instances())\n"
] | [
"def test_b_create_server_group(self):...\n",
"self.run_test_case(self.scenario.create_instances())\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_7(VAR_7, VAR_12):...\n",
"VAR_9 = FUNC_6(VAR_7, 'Main')\n",
"VAR_9.cmd('send-keys', VAR_12, 'Enter')\n"
] | [
"def send_main_session_command(session, cmd):...\n",
"window = find_window(session, 'Main')\n",
"window.cmd('send-keys', cmd, 'Enter')\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'"
] |
[
"def __init__(self, *VAR_0, **VAR_1):...\n",
"super().__init__(*VAR_0, **kwargs)\n"
] | [
"def __init__(self, *args, **kwargs):...\n",
"super().__init__(*args, **kwargs)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_7(self, VAR_9, VAR_10):...\n",
"VAR_19 = urllib2.Request(self.url + VAR_9, urllib.urlencode(VAR_10))\n",
"VAR_20 = self._opener.open(VAR_19)\n",
"return VAR_20.read()\n"
] | [
"def post(self, suburl, data):...\n",
"request = urllib2.Request(self.url + suburl, urllib.urlencode(data))\n",
"f = self._opener.open(request)\n",
"return f.read()\n"
] | [
0,
5,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_9(self, *VAR_15, **VAR_75):...\n",
""
] | [
"def newfn(self, *a, **env):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_34(VAR_8, VAR_11):...\n",
"return sum(len(VAR_34) for c, VAR_34 in VAR_8.items() if c.check.name == VAR_11\n )\n"
] | [
"def num_deps(graph, cname):...\n",
"return sum(len(deps) for c, deps in graph.items() if c.check.name == cname)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"@classmethod...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_35 = VAR_14.search_keyword(VAR_22, VAR_16=1000) if VAR_22 else select(g for\n g in VAR_14)\n",
"if VAR_20:\n",
"if VAR_20 == 'HEALTH':\n",
"return VAR_35\n",
"VAR_35 = VAR_35.sort_by('(g.health.seeders, g.health.leechers)'\n ) if VAR_21 else VAR_35.sort_by(\n '(desc(g.health.seeders), desc(g.health.leechers))')\n",
"VAR_44 = 'g.' + VAR_20\n",
"VAR_44 = VAR_44 if VAR_21 else desc(VAR_44)\n",
"VAR_35 = VAR_35.sort_by(VAR_44)\n"
] | [
"@classmethod...\n",
"\"\"\"docstring\"\"\"\n",
"pony_query = cls.search_keyword(query_filter, lim=1000\n ) if query_filter else select(g for g in cls)\n",
"if sort_by:\n",
"if sort_by == 'HEALTH':\n",
"return pony_query\n",
"pony_query = pony_query.sort_by('(g.health.seeders, g.health.leechers)'\n ) if sort_asc else pony_query.sort_by(\n '(desc(g.health.seeders), desc(g.health.leechers))')\n",
"sort_expression = 'g.' + sort_by\n",
"sort_expression = sort_expression if sort_asc else desc(sort_expression)\n",
"pony_query = pony_query.sort_by(sort_expression)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Condition",
"Condition",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_2(VAR_1):...\n",
"VAR_9 = getRankingsFromDatabase(VAR_1)\n",
"VAR_10 = ''\n",
"VAR_11 = 0\n",
"for VAR_2, row in enumerate(VAR_9):\n",
"if VAR_2 != 0:\n",
"VAR_12 = createAndUploadPlots(VAR_9, VAR_1.id)\n",
"if VAR_9[VAR_2][1] != VAR_9[VAR_2 - 1][1] or VAR_9[VAR_2][2] != VAR_9[VAR_2 - 1\n",
"VAR_10 += str(VAR_11 + 1) + FUNC_3(VAR_11 + 1)\n",
"VAR_13 = FUNC_4(VAR_1)\n",
"VAR_11 = VAR_2\n",
"for i, val in enumerate(row):\n",
"print('I have found ' + str(VAR_13) +\n \"\"\" challenges in this series so far:\n\nRanking|User|1st|2nd|3rd\n:--|:--|:--|:--|:--\n\"\"\"\n + VAR_10 + '\\n\\n[Here](' + VAR_12 + 'string')\n",
"if i == 0:\n",
"VAR_10 += '\\n'\n",
"VAR_10 += '|/u/' + str(val)\n",
"VAR_10 += '|' + str(val)\n"
] | [
"def replyTrackedStats(submission):...\n",
"table = getRankingsFromDatabase(submission)\n",
"text = ''\n",
"place = 0\n",
"for index, row in enumerate(table):\n",
"if index != 0:\n",
"url = createAndUploadPlots(table, submission.id)\n",
"if table[index][1] != table[index - 1][1] or table[index][2] != table[index - 1\n",
"text += str(place + 1) + getPostFix(place + 1)\n",
"gameCount = getGameCountInSeriesSoFar(submission)\n",
"place = index\n",
"for i, val in enumerate(row):\n",
"print('I have found ' + str(gameCount) +\n \"\"\" challenges in this series so far:\n\nRanking|User|1st|2nd|3rd\n:--|:--|:--|:--|:--\n\"\"\"\n + text + '\\n\\n[Here](' + url +\n \"\"\") is a visualization of the current stats.\n\n---\n\n^(I'm a bot, message the author: /u/LiquidProgrammer if I made a mistake.) ^[Usage](https://www.reddit.com/r/geoguessr/comments/6haay2/).\"\"\"\n )\n",
"if i == 0:\n",
"text += '\\n'\n",
"text += '|/u/' + str(val)\n",
"text += '|' + str(val)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Condition",
"Assign'",
"Condition",
"AugAssign'",
"Assign'",
"Assign'",
"For",
"Expr'",
"Condition",
"AugAssign'",
"AugAssign'",
"AugAssign'"
] |
[
"def FUNC_25(self, VAR_73):...\n",
"def FUNC_39(VAR_101):...\n",
"VAR_101.message = VAR_73\n",
"return VAR_101\n"
] | [
"def message(self, message):...\n",
"def decorate(ruleinfo):...\n",
"ruleinfo.message = message\n",
"return ruleinfo\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_12(self):...\n",
"VAR_21 = []\n",
"VAR_18 = threading.Event()\n",
"self.mock(VAR_18, 'wait', self.fail)\n",
"self.mock(bot_main, 'run_manifest', self.fail)\n",
"self.mock(bot_main, 'update_bot', self.fail)\n",
"self.mock(self.bot, 'restart', lambda *VAR_24: VAR_21.append(VAR_24))\n",
"self.expected_requests([(\n 'https://localhost:1/auth/api/v1/accounts/self/xsrf_token', {'data': {},\n 'headers': {'X-XSRF-Token-Request': '1'}}, {'xsrf_token': 'token'}), (\n 'https://localhost:1/swarming/api/v1/bot/poll', {'data': self.\n attributes, 'headers': {'X-XSRF-Token': 'token'}}, {'cmd': 'restart',\n 'message': 'Please die now'})])\n",
"self.assertTrue(bot_main.poll_server(self.bot, VAR_18))\n",
"self.assertEqual([('Please die now',)], VAR_21)\n"
] | [
"def test_poll_server_restart(self):...\n",
"restart = []\n",
"bit = threading.Event()\n",
"self.mock(bit, 'wait', self.fail)\n",
"self.mock(bot_main, 'run_manifest', self.fail)\n",
"self.mock(bot_main, 'update_bot', self.fail)\n",
"self.mock(self.bot, 'restart', lambda *args: restart.append(args))\n",
"self.expected_requests([(\n 'https://localhost:1/auth/api/v1/accounts/self/xsrf_token', {'data': {},\n 'headers': {'X-XSRF-Token-Request': '1'}}, {'xsrf_token': 'token'}), (\n 'https://localhost:1/swarming/api/v1/bot/poll', {'data': self.\n attributes, 'headers': {'X-XSRF-Token': 'token'}}, {'cmd': 'restart',\n 'message': 'Please die now'})])\n",
"self.assertTrue(bot_main.poll_server(self.bot, bit))\n",
"self.assertEqual([('Please die now',)], restart)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"@pytest.mark.skip(reason='Rhyming not implemented yet')...\n",
"FUNC_2(VAR_2)\n",
"FUNC_3(VAR_2, 'GAYLEDESIGNS INC.', VAR_7='1')\n",
"FUNC_3(VAR_2, 'GOLDSTREAM ELECTRICAL CORP', VAR_7='2')\n",
"FUNC_3(VAR_2, 'GLADSTONE JEWELLERY LTD', VAR_7='3')\n",
"FUNC_3(VAR_2, 'GOLDSTEIN HOLDINGS INC.', VAR_7='4')\n",
"FUNC_3(VAR_2, 'CLOUDSIDE INN INCORPORATED', VAR_7='5')\n",
"FUNC_3(VAR_2, 'GOLDSPRING PROPERTIES LTD', VAR_7='6')\n",
"FUNC_3(VAR_2, 'GOLDSTRIPES AVIATION INC', VAR_7='7')\n",
"FUNC_3(VAR_2, 'GLADSTONE CAPITAL CORP', VAR_7='8')\n",
"FUNC_3(VAR_2, 'KLETAS LAW CORPORATION', VAR_7='9')\n",
"FUNC_3(VAR_2, 'COLDSTREAM VENTURES INC.', VAR_7='10')\n",
"FUNC_3(VAR_2, 'BLABLA ANYTHING', VAR_7='11')\n",
"FUNC_5(VAR_4, VAR_5, VAR_11='GOLDSMITHS', VAR_10=[{'name': '----GOLDSMITHS'\n }, {'name': 'COLDSTREAM VENTURES INC.'}, {'name':\n 'GOLDSPRING PROPERTIES LTD'}, {'name': 'GOLDSTEIN HOLDINGS INC.'}, {\n 'name': 'GOLDSTREAM ELECTRICAL CORP'}, {'name':\n 'GOLDSTRIPES AVIATION INC'}])\n"
] | [
"@pytest.mark.skip(reason='Rhyming not implemented yet')...\n",
"clean_database(solr)\n",
"seed_database_with(solr, 'GAYLEDESIGNS INC.', id='1')\n",
"seed_database_with(solr, 'GOLDSTREAM ELECTRICAL CORP', id='2')\n",
"seed_database_with(solr, 'GLADSTONE JEWELLERY LTD', id='3')\n",
"seed_database_with(solr, 'GOLDSTEIN HOLDINGS INC.', id='4')\n",
"seed_database_with(solr, 'CLOUDSIDE INN INCORPORATED', id='5')\n",
"seed_database_with(solr, 'GOLDSPRING PROPERTIES LTD', id='6')\n",
"seed_database_with(solr, 'GOLDSTRIPES AVIATION INC', id='7')\n",
"seed_database_with(solr, 'GLADSTONE CAPITAL CORP', id='8')\n",
"seed_database_with(solr, 'KLETAS LAW CORPORATION', id='9')\n",
"seed_database_with(solr, 'COLDSTREAM VENTURES INC.', id='10')\n",
"seed_database_with(solr, 'BLABLA ANYTHING', id='11')\n",
"verify_results(client, jwt, query='GOLDSMITHS', expected=[{'name':\n '----GOLDSMITHS'}, {'name': 'COLDSTREAM VENTURES INC.'}, {'name':\n 'GOLDSPRING PROPERTIES LTD'}, {'name': 'GOLDSTEIN HOLDINGS INC.'}, {\n 'name': 'GOLDSTREAM ELECTRICAL CORP'}, {'name':\n 'GOLDSTRIPES AVIATION INC'}])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_0(VAR_0):...\n",
"\"\"\"docstring\"\"\"\n",
"if isinstance(VAR_0, collections.Mapping):\n",
"return VAR_0\n",
"if hasattr(VAR_0, 'read') and callable(VAR_0.read):\n",
"VAR_13 = VAR_0.read()\n",
"if os.path.exists(os.path.expanduser(str(VAR_0))):\n",
"return json.loads(VAR_13)\n",
"return yaml.load(VAR_13)\n",
"VAR_13 = source_file.read()\n",
"if isinstance(VAR_0, six.string_types):\n",
"VAR_14 = urlparse.urlparse(VAR_0)\n",
"if VAR_14.scheme and VAR_14.netloc:\n",
"VAR_12 = requests.get(VAR_0)\n",
"VAR_13 = VAR_0\n",
"if isinstance(VAR_12.content, six.binary_type):\n",
"VAR_13 = six.text_type(VAR_12.content, encoding='utf-8')\n",
"VAR_13 = VAR_12.content\n"
] | [
"def load_source(source):...\n",
"\"\"\"docstring\"\"\"\n",
"if isinstance(source, collections.Mapping):\n",
"return source\n",
"if hasattr(source, 'read') and callable(source.read):\n",
"raw_source = source.read()\n",
"if os.path.exists(os.path.expanduser(str(source))):\n",
"return json.loads(raw_source)\n",
"return yaml.load(raw_source)\n",
"raw_source = source_file.read()\n",
"if isinstance(source, six.string_types):\n",
"parts = urlparse.urlparse(source)\n",
"if parts.scheme and parts.netloc:\n",
"response = requests.get(source)\n",
"raw_source = source\n",
"if isinstance(response.content, six.binary_type):\n",
"raw_source = six.text_type(response.content, encoding='utf-8')\n",
"raw_source = response.content\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
7,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Return'",
"Condition",
"Assign'",
"Condition",
"Return'",
"Return'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'"
] |
[
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_5 = self.config.get(self.section, 'verify_request_signatures')\n",
"return bool(int(VAR_5))\n"
] | [
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"res = self.config.get(self.section, 'verify_request_signatures')\n",
"return bool(int(res))\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Return'"
] |
[
"def FUNC_21(VAR_12, VAR_13):...\n",
"for VAR_7 in VAR_2.providers:\n",
"if VAR_7.id == VAR_12 and VAR_7.url == VAR_13:\n",
"self.fail('Provider: %s not found' % VAR_12)\n",
"return\n"
] | [
"def _assert_provider(pid, purl):...\n",
"for provider in cluster_api.providers:\n",
"if provider.id == pid and provider.url == purl:\n",
"self.fail('Provider: %s not found' % pid)\n",
"return\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"For",
"Condition",
"Expr'",
"Return'"
] |
[
"def FUNC_0(self, VAR_1, VAR_6, VAR_7, VAR_3):...\n",
"Attribute.make_input(self, VAR_1, VAR_6, '%g' % VAR_7, VAR_3)\n"
] | [
"def make_input(self, version, name, value, attribute):...\n",
"Attribute.make_input(self, version, name, '%g' % value, attribute)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"\"\"\"string\"\"\"\n",
"import time\n",
"import unittest\n",
"import psycopg2\n",
"import tournament\n",
"import tools\n",
"def FUNC_0():...\n",
"return psycopg2.connect(database='tournament', user='postgres')\n"
] | [
"\"\"\" The master Unit test set up. Each set of tests below should cover all\nfunctional aspects of tournament.py. The original file tournament_test.py has\nbeen rolled in here and its tests exist below. Most tests below are YAY/NAY\nin that we're expecitng very specific results. In most cases, each function\nin tournament.py returns a status code based on its behavior. These codes are\nreturned when non-critical events take place such as \"no players found\" when\ntrying to search for players.\n\"\"\"\n",
"import time\n",
"import unittest\n",
"import psycopg2\n",
"import tournament\n",
"import tools\n",
"def connect():...\n",
"return psycopg2.connect(database='tournament', user='postgres')\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"Import'",
"Import'",
"Import'",
"Import'",
"Import'",
"FunctionDef'",
"Return'"
] |
[
"def FUNC_1():...\n",
"VAR_1 = [{'fieldname': 'territory', 'fieldtype': 'Link', 'label': _(\n 'Territory'), 'options': 'Territory', 'width': 100}, {'fieldname':\n 'item_group', 'fieldtype': 'Link', 'label': _('Item Group'), 'options':\n 'Item Group', 'width': 150}, {'fieldname': 'item_name', 'fieldtype':\n 'Link', 'options': 'Item', 'label': 'Item', 'width': 150}, {'fieldname':\n 'item_name', 'fieldtype': 'Data', 'label': _('Item Name'), 'width': 150\n }, {'fieldname': 'customer', 'fieldtype': 'Link', 'label': _('Customer'\n ), 'options': 'Customer', 'width': 100}, {'fieldname':\n 'last_order_date', 'fieldtype': 'Date', 'label': _('Last Order Date'),\n 'width': 100}, {'fieldname': 'qty', 'fieldtype': 'Float', 'label': _(\n 'Quantity'), 'width': 100}, {'fieldname': 'days_since_last_order',\n 'fieldtype': 'Int', 'label': _('Days Since Last Order'), 'width': 100}]\n",
"return VAR_1\n"
] | [
"def get_columns():...\n",
"columns = [{'fieldname': 'territory', 'fieldtype': 'Link', 'label': _(\n 'Territory'), 'options': 'Territory', 'width': 100}, {'fieldname':\n 'item_group', 'fieldtype': 'Link', 'label': _('Item Group'), 'options':\n 'Item Group', 'width': 150}, {'fieldname': 'item_name', 'fieldtype':\n 'Link', 'options': 'Item', 'label': 'Item', 'width': 150}, {'fieldname':\n 'item_name', 'fieldtype': 'Data', 'label': _('Item Name'), 'width': 150\n }, {'fieldname': 'customer', 'fieldtype': 'Link', 'label': _('Customer'\n ), 'options': 'Customer', 'width': 100}, {'fieldname':\n 'last_order_date', 'fieldtype': 'Date', 'label': _('Last Order Date'),\n 'width': 100}, {'fieldname': 'qty', 'fieldtype': 'Float', 'label': _(\n 'Quantity'), 'width': 100}, {'fieldname': 'days_since_last_order',\n 'fieldtype': 'Int', 'label': _('Days Since Last Order'), 'width': 100}]\n",
"return columns\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_6(self):...\n",
"VAR_21 = ', '.join(self.column_selects)\n",
"return 'COALESCE({0}) AS {1}'.format(VAR_21, self.name)\n"
] | [
"def select(self):...\n",
"fields = ', '.join(self.column_selects)\n",
"return 'COALESCE({0}) AS {1}'.format(fields, self.name)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_1(self, VAR_5):...\n",
"VAR_7 = False\n",
"VAR_8 = str(VAR_5.event_type_id.name).lower()\n",
"VAR_9 = datetime.strptime(VAR_5.date_begin, '%Y-%m-%d %H:%M:%S')\n",
"if VAR_8 == 'open' and len(self.fit_subscriptions) > 0:\n",
"VAR_0.info('Can subscribe for open event id: %s, name: %s', VAR_5.\n event_type_id.name, VAR_5.name)\n",
"if VAR_9 < datetime.now():\n",
"return True\n",
"return False\n",
"if VAR_9 + relativedelta(hours=-24) > datetime.now(\n",
"return False\n",
"for subscription in self.fit_subscriptions:\n",
"if subscription._can_subscribe(VAR_5.event_type_id):\n",
"return VAR_7\n",
"VAR_0.info('Can subscribe for event id: %s, name: %s', VAR_5.event_type_id.\n name, VAR_5.name)\n",
"VAR_7 = True\n"
] | [
"def can_subscribe(self, event):...\n",
"can_subscribe = False\n",
"event_type = str(event.event_type_id.name).lower()\n",
"event_start = datetime.strptime(event.date_begin, '%Y-%m-%d %H:%M:%S')\n",
"if event_type == 'open' and len(self.fit_subscriptions) > 0:\n",
"_logger.info('Can subscribe for open event id: %s, name: %s', event.\n event_type_id.name, event.name)\n",
"if event_start < datetime.now():\n",
"return True\n",
"return False\n",
"if event_start + relativedelta(hours=-24) > datetime.now(\n",
"return False\n",
"for subscription in self.fit_subscriptions:\n",
"if subscription._can_subscribe(event.event_type_id):\n",
"return can_subscribe\n",
"_logger.info('Can subscribe for event id: %s, name: %s', event.\n event_type_id.name, event.name)\n",
"can_subscribe = True\n"
] | [
0,
0,
0,
0,
6,
6,
0,
6,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Condition",
"Return'",
"Return'",
"Condition",
"Return'",
"For",
"Condition",
"Return'",
"Expr'",
"Assign'"
] |
[
"def FUNC_9(VAR_6):...\n",
"VAR_12 = f\"\"\"\n SELECT id from {VAR_3}\n WHERE user_id={VAR_6}\n ORDER BY transaction_date DESC\n LIMIT 1\n \"\"\"\n",
"VAR_14 = create_connection()\n",
"VAR_14.close()\n",
"VAR_15 = VAR_14.cursor()\n",
"VAR_15.execute(VAR_12)\n",
"return VAR_15.fetchone()\n"
] | [
"def get_invoice_id(userId):...\n",
"sql_query = f\"\"\"\n SELECT id from {INVOICES_TABLE}\n WHERE user_id={userId}\n ORDER BY transaction_date DESC\n LIMIT 1\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'"
] |
[
"@classmethod...\n",
"return ()\n"
] | [
"@classmethod...\n",
"return ()\n"
] | [
0,
0
] | [
"Condition",
"Return'"
] |
[
"def __init__(self, *VAR_2, **VAR_3):...\n",
"super(CLASS_0, self).__init__(*VAR_2, **kwargs)\n",
"self.common = None\n",
"self.configuration.append_config_values(hpcommon.hp3par_opts)\n",
"self.configuration.append_config_values(san.san_opts)\n"
] | [
"def __init__(self, *args, **kwargs):...\n",
"super(HP3PARFCDriver, self).__init__(*args, **kwargs)\n",
"self.common = None\n",
"self.configuration.append_config_values(hpcommon.hp3par_opts)\n",
"self.configuration.append_config_values(san.san_opts)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"@property...\n",
"return self._input\n"
] | [
"@property...\n",
"return self._input\n"
] | [
0,
0
] | [
"Condition",
"Return'"
] |
[
"\"\"\"\nImplementation of a help command.\n\"\"\"\n",
"import asyncio\n",
"import inspect\n",
"import random\n",
"import discord\n",
"import neko\n",
"__all__ = ['HelpCog', 'ActivityChangerCog', 'setup']\n",
"VAR_0 = 2003199\n",
"\"\"\"Provides the inner methods with access to bot directly.\"\"\"\n",
"VAR_2 = (neko.Permissions.SEND_MESSAGES | neko.Permissions.ADD_REACTIONS |\n neko.Permissions.READ_MESSAGES | neko.Permissions.MANAGE_MESSAGES)\n",
"def __init__(self, VAR_1: neko.NekoBot):...\n",
"\"\"\"docstring\"\"\"\n",
"self.bot = VAR_1\n",
"@neko.command(VAR_21='rtfm', VAR_17=...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_7 = neko.Book(VAR_3)\n",
"VAR_8 = {}\n",
"VAR_7 += await self.gen_front_page(VAR_3)\n",
"VAR_8[None] = 0\n",
"VAR_9 = sorted(set(self.bot.walk_commands()), key=lambda c: c.qualified_name)\n",
"VAR_10 = len(VAR_7)\n",
"for i, VAR_5 in enumerate(VAR_9):\n",
"VAR_7 += await self.gen_spec_page(VAR_3, VAR_5)\n",
"VAR_24 = VAR_8[VAR_4]\n",
"await VAR_3.send(f'I could not find a command called {VAR_4}!')\n",
"VAR_7.index = VAR_24\n",
"VAR_8[VAR_5.qualified_name] = i + VAR_10\n",
"async def FUNC_2(self, VAR_3: neko.Context) ->neko.Page:...\n",
"await VAR_7.send()\n",
"\"\"\"docstring\"\"\"\n",
"VAR_11 = f'{neko.__copyright__} under the {neko.__license__} license.\\n\\n'\n",
"VAR_12 = inspect.getdoc(neko)\n",
"VAR_12 = inspect.cleandoc(VAR_12 if VAR_12 else '')\n",
"VAR_11 += neko.remove_single_lines(VAR_12)\n",
"VAR_13 = neko.Page(title=f'{neko.__title__} v{neko.__version__}',\n description=desc, VAR_28=default_color, url=neko.__repository__)\n",
"VAR_13.set_thumbnail(url=self.bot.user.avatar_url)\n",
"VAR_13.add_field(VAR_21='Repository', value=neko.__repository__)\n",
"VAR_14 = await self.bot.is_owner(VAR_3.author)\n",
"VAR_9 = sorted(self.bot.commands, key=lambda c: c.name)\n",
"VAR_9 = [self.format_command_name(VAR_5) for VAR_5 in VAR_9 if VAR_14 or \n not VAR_5.hidden]\n",
"VAR_13.add_field(VAR_21='Available commands', value=', '.join(cmds), inline\n =False)\n",
"return VAR_13\n"
] | [
"\"\"\"\nImplementation of a help command.\n\"\"\"\n",
"import asyncio\n",
"import inspect\n",
"import random\n",
"import discord\n",
"import neko\n",
"__all__ = ['HelpCog', 'ActivityChangerCog', 'setup']\n",
"default_color = 2003199\n",
"\"\"\"Provides the inner methods with access to bot directly.\"\"\"\n",
"permissions = (neko.Permissions.SEND_MESSAGES | neko.Permissions.\n ADD_REACTIONS | neko.Permissions.READ_MESSAGES | neko.Permissions.\n MANAGE_MESSAGES)\n",
"def __init__(self, bot: neko.NekoBot):...\n",
"\"\"\"docstring\"\"\"\n",
"self.bot = bot\n",
"@neko.command(name='rtfm', brief=...\n",
"\"\"\"docstring\"\"\"\n",
"bk = neko.Book(ctx)\n",
"command_to_page = {}\n",
"bk += await self.gen_front_page(ctx)\n",
"command_to_page[None] = 0\n",
"cmds = sorted(set(self.bot.walk_commands()), key=lambda c: c.qualified_name)\n",
"offset = len(bk)\n",
"for i, cmd in enumerate(cmds):\n",
"bk += await self.gen_spec_page(ctx, cmd)\n",
"page_index = command_to_page[query]\n",
"await ctx.send(f'I could not find a command called {query}!')\n",
"bk.index = page_index\n",
"command_to_page[cmd.qualified_name] = i + offset\n",
"async def gen_front_page(self, ctx: neko.Context) ->neko.Page:...\n",
"await bk.send()\n",
"\"\"\"docstring\"\"\"\n",
"desc = f'{neko.__copyright__} under the {neko.__license__} license.\\n\\n'\n",
"doc_str = inspect.getdoc(neko)\n",
"doc_str = inspect.cleandoc(doc_str if doc_str else '')\n",
"desc += neko.remove_single_lines(doc_str)\n",
"page = neko.Page(title=f'{neko.__title__} v{neko.__version__}', description\n =desc, color=default_color, url=neko.__repository__)\n",
"page.set_thumbnail(url=self.bot.user.avatar_url)\n",
"page.add_field(name='Repository', value=neko.__repository__)\n",
"is_bot_owner = await self.bot.is_owner(ctx.author)\n",
"cmds = sorted(self.bot.commands, key=lambda c: c.name)\n",
"cmds = [self.format_command_name(cmd) for cmd in cmds if is_bot_owner or \n not cmd.hidden]\n",
"page.add_field(name='Available commands', value=', '.join(cmds), inline=False)\n",
"return page\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"Import'",
"Import'",
"Import'",
"Import'",
"Import'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Docstring",
"Assign'",
"Assign'",
"AugAssign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"AugAssign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"AsyncFunctionDef'",
"Expr'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"AugAssign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"\"\"\"Set of functions for tasks to freeze the data within a GSoCProgram.\n\"\"\"\n",
"__authors__ = ['\"Daniel Hans\" <[email protected]>',\n '\"Lennard de Rijk\" <[email protected]>']\n",
"import pickle\n",
"from google.appengine.ext import db\n",
"from soc.tasks import responses\n",
"from soc.tasks.helper import error_handler\n",
"from soc.modules.gsoc.logic.models.mentor import logic as mentor_logic\n",
"from soc.modules.gsoc.logic.models.org_admin import logic as org_admin_logic\n",
"from soc.modules.gsoc.logic.models.organization import logic as org_logic\n",
"from soc.modules.gsoc.logic.models.program import logic as program_logic\n",
"from soc.modules.gsoc.logic.models.student import logic as student_logic\n",
"VAR_0 = [('^tasks/gsoc/freezer/manage_students_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageStudentsStatus')]\n",
"VAR_1 = [('^tasks/gsoc/freezer/manage_mentors_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageMentorsStatus'), (\n '^tasks/gsoc/freezer/manage_org_admins_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageOrgAdminsStatus')]\n",
"VAR_2 = [('^tasks/gsoc/freezer/manage_orgs_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageOrgsStatus')]\n",
"VAR_3 = VAR_0 + VAR_1 + VAR_2\n",
"VAR_4 = 50\n",
"def FUNC_0():...\n",
"\"\"\"docstring\"\"\"\n",
"return VAR_3\n"
] | [
"\"\"\"Set of functions for tasks to freeze the data within a GSoCProgram.\n\"\"\"\n",
"__authors__ = ['\"Daniel Hans\" <[email protected]>',\n '\"Lennard de Rijk\" <[email protected]>']\n",
"import pickle\n",
"from google.appengine.ext import db\n",
"from soc.tasks import responses\n",
"from soc.tasks.helper import error_handler\n",
"from soc.modules.gsoc.logic.models.mentor import logic as mentor_logic\n",
"from soc.modules.gsoc.logic.models.org_admin import logic as org_admin_logic\n",
"from soc.modules.gsoc.logic.models.organization import logic as org_logic\n",
"from soc.modules.gsoc.logic.models.program import logic as program_logic\n",
"from soc.modules.gsoc.logic.models.student import logic as student_logic\n",
"ROLE_PER_SCOPE_MODELS_URL_PATTERNS = [(\n '^tasks/gsoc/freezer/manage_students_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageStudentsStatus')]\n",
"ROLE_PER_PROGRAM_MODELS_URL_PATTERNS = [(\n '^tasks/gsoc/freezer/manage_mentors_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageMentorsStatus'), (\n '^tasks/gsoc/freezer/manage_org_admins_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageOrgAdminsStatus')]\n",
"ORG_MODEL_URL_PATTERNS = [('^tasks/gsoc/freezer/manage_orgs_status$',\n 'soc.modules.gsoc.tasks.program_freezer.manageOrgsStatus')]\n",
"ROLE_MODELS_URL_PATTERNS = (ROLE_PER_SCOPE_MODELS_URL_PATTERNS +\n ROLE_PER_PROGRAM_MODELS_URL_PATTERNS + ORG_MODEL_URL_PATTERNS)\n",
"BATCH_SIZE = 50\n",
"def getDjangoURLPatterns():...\n",
"\"\"\"docstring\"\"\"\n",
"return ROLE_MODELS_URL_PATTERNS\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"Assign'",
"Import'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def FUNC_0(VAR_0):...\n",
"from os import path\n",
"if not path.exists('./data/ed.db'):\n",
"from to_sqlalchemy import update\n",
"VAR_0.add_cog(CLASS_0(VAR_0))\n",
"FUNC_8()\n"
] | [
"def setup(bot):...\n",
"from os import path\n",
"if not path.exists('./data/ed.db'):\n",
"from to_sqlalchemy import update\n",
"bot.add_cog(EDDB(bot))\n",
"update()\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"ImportFrom'",
"Condition",
"ImportFrom'",
"Expr'",
"Expr'"
] |
[
"def FUNC_15(self, VAR_18, VAR_19, VAR_20):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_49 = VAR_19.sub_names_idx[VAR_18.file_name]\n",
"for VAR_65 in VAR_18.sub_items:\n",
"VAR_65.parent = VAR_18\n",
"VAR_18.uuid = FUNC_1(None, self.fs_uuid_idx)\n",
"VAR_18.sub_names_idx[VAR_65.file_name] = VAR_65\n",
"self.fs_uuid_idx[VAR_18.uuid] = VAR_18\n",
"self._copy_recursive(VAR_65, VAR_49, VAR_20)\n",
"VAR_18.upload_time = FUNC_0()\n",
"if VAR_20:\n",
"VAR_18.owner = VAR_20\n",
"if VAR_18.is_dir:\n",
"self._insert_in_db(VAR_18)\n",
"return\n"
] | [
"def _copy_recursive(self, item, target_par, new_owner):...\n",
"\"\"\"docstring\"\"\"\n",
"target_node = target_par.sub_names_idx[item.file_name]\n",
"for i_sub in item.sub_items:\n",
"i_sub.parent = item\n",
"item.uuid = get_new_uuid(None, self.fs_uuid_idx)\n",
"item.sub_names_idx[i_sub.file_name] = i_sub\n",
"self.fs_uuid_idx[item.uuid] = item\n",
"self._copy_recursive(i_sub, target_node, new_owner)\n",
"item.upload_time = get_current_time()\n",
"if new_owner:\n",
"item.owner = new_owner\n",
"if item.is_dir:\n",
"self._insert_in_db(item)\n",
"return\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"For",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Expr'",
"Return'"
] |
[
"def FUNC_6(self):...\n",
"VAR_12 = Client()\n",
"self.response = VAR_12.get('{}?{}'.format(reverse('login-redirect'),\n 'token=ABXZ'))\n",
"return self\n"
] | [
"def when_call_login_email_redirect(self):...\n",
"client = Client()\n",
"self.response = client.get('{}?{}'.format(reverse('login-redirect'),\n 'token=ABXZ'))\n",
"return self\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_10(self):...\n",
"VAR_19 = []\n",
"VAR_18 = threading.Event()\n",
"self.mock(VAR_18, 'wait', self.fail)\n",
"self.mock(bot_main, 'run_manifest', lambda *VAR_24: VAR_19.append(VAR_24))\n",
"self.mock(bot_main, 'update_bot', self.fail)\n",
"self.expected_requests([(\n 'https://localhost:1/auth/api/v1/accounts/self/xsrf_token', {'data': {},\n 'headers': {'X-XSRF-Token-Request': '1'}}, {'xsrf_token': 'token'}), (\n 'https://localhost:1/swarming/api/v1/bot/poll', {'data': self.bot.\n _attributes, 'headers': {'X-XSRF-Token': 'token'}}, {'cmd': 'run',\n 'manifest': {'foo': 'bar'}})])\n",
"self.assertTrue(bot_main.poll_server(self.bot, VAR_18))\n",
"VAR_6 = [(self.bot, {'foo': 'bar'}, time.time())]\n",
"self.assertEqual(VAR_6, VAR_19)\n"
] | [
"def test_poll_server_run(self):...\n",
"manifest = []\n",
"bit = threading.Event()\n",
"self.mock(bit, 'wait', self.fail)\n",
"self.mock(bot_main, 'run_manifest', lambda *args: manifest.append(args))\n",
"self.mock(bot_main, 'update_bot', self.fail)\n",
"self.expected_requests([(\n 'https://localhost:1/auth/api/v1/accounts/self/xsrf_token', {'data': {},\n 'headers': {'X-XSRF-Token-Request': '1'}}, {'xsrf_token': 'token'}), (\n 'https://localhost:1/swarming/api/v1/bot/poll', {'data': self.bot.\n _attributes, 'headers': {'X-XSRF-Token': 'token'}}, {'cmd': 'run',\n 'manifest': {'foo': 'bar'}})])\n",
"self.assertTrue(bot_main.poll_server(self.bot, bit))\n",
"expected = [(self.bot, {'foo': 'bar'}, time.time())]\n",
"self.assertEqual(expected, manifest)\n"
] | [
0,
0,
0,
0,
0,
0,
5,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"@VAR_0.route('/register', methods=['GET', 'POST'])...\n",
"VAR_46 = CLASS_0(request.form)\n",
"if request.method == 'POST' and VAR_46.validate():\n",
"VAR_41 = VAR_46.name.data\n",
"return render_template('register.html', VAR_46=form)\n",
"VAR_43 = VAR_46.email.data\n",
"VAR_42 = VAR_46.username.data\n",
"VAR_44 = sha256_crypt.encrypt(str(VAR_46.password.data))\n",
"VAR_28 = VAR_1.connection.cursor()\n",
"VAR_28.execute(\n 'INSERT INTO Users(name, email, username, password) VALUES(%s, %s, %s, %s)'\n , (VAR_41, VAR_43, VAR_42, VAR_44))\n",
"VAR_1.connection.commit()\n",
"VAR_28.close()\n",
"flash('You are now registered and can log in', 'success')\n",
"return redirect(url_for('login'))\n"
] | [
"@app.route('/register', methods=['GET', 'POST'])...\n",
"form = RegisterForm(request.form)\n",
"if request.method == 'POST' and form.validate():\n",
"name = form.name.data\n",
"return render_template('register.html', form=form)\n",
"email = form.email.data\n",
"username = form.username.data\n",
"password = sha256_crypt.encrypt(str(form.password.data))\n",
"cur = mysql.connection.cursor()\n",
"cur.execute(\n 'INSERT INTO Users(name, email, username, password) VALUES(%s, %s, %s, %s)'\n , (name, email, username, password))\n",
"mysql.connection.commit()\n",
"cur.close()\n",
"flash('You are now registered and can log in', 'success')\n",
"return redirect(url_for('login'))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Return'"
] |
[
"def FUNC_3(VAR_2):...\n",
"VAR_13 = VAR_2[5:25]\n",
"return datetime.datetime.strptime(VAR_13, '%d %b %Y %H:%M:%S')\n"
] | [
"def get_datetime(date):...\n",
"sliced_date = date[5:25]\n",
"return datetime.datetime.strptime(sliced_date, '%d %b %Y %H:%M:%S')\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"@VAR_0.route('/video/<filename>')...\n",
"if 'username' in VAR_19:\n",
"return render_template('video_viewing_screen.html', video_name=filename)\n",
"return redirect(url_for('index'))\n"
] | [
"@app.route('/video/<filename>')...\n",
"if 'username' in session:\n",
"return render_template('video_viewing_screen.html', video_name=filename)\n",
"return redirect(url_for('index'))\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Return'"
] |
[
"\"\"\"string\"\"\"\n",
"import mimetypes\n",
"import os\n",
"import posixpath\n",
"import re\n",
"import stat\n",
"from django.http import FileResponse, Http404, HttpResponse, HttpResponseNotModified, HttpResponseRedirect\n",
"from django.template import Context, Engine, TemplateDoesNotExist, loader\n",
"from django.utils.http import http_date, parse_http_date\n",
"from django.utils.translation import gettext as _, gettext_lazy\n",
"def FUNC_0(VAR_0, VAR_1, VAR_2=None, VAR_3=False):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_1 = posixpath.normpath(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"
] | [
"\"\"\"\nViews and functions for serving static files. These are only to be used\nduring development, and SHOULD NOT be used in a production setting.\n\"\"\"\n",
"import mimetypes\n",
"import os\n",
"import posixpath\n",
"import re\n",
"import stat\n",
"from django.http import FileResponse, Http404, HttpResponse, HttpResponseNotModified, HttpResponseRedirect\n",
"from django.template import Context, Engine, TemplateDoesNotExist, loader\n",
"from django.utils.http import http_date, parse_http_date\n",
"from django.utils.translation import gettext as _, gettext_lazy\n",
"def serve(request, path, document_root=None, show_indexes=False):...\n",
"\"\"\"docstring\"\"\"\n",
"path = posixpath.normpath(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,
0,
0,
0,
0,
6,
0,
0,
0,
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
] | [
"Expr'",
"Import'",
"Import'",
"Import'",
"Import'",
"Import'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"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_3(self, VAR_6):...\n",
"self.common = self._init_common()\n",
"self._check_flags()\n",
"self.iscsi_ips = {}\n",
"VAR_21 = {}\n",
"if len(self.configuration.hp3par_iscsi_ips) > 0:\n",
"for VAR_42 in self.configuration.hp3par_iscsi_ips:\n",
"if self.configuration.iscsi_ip_address not in VAR_21:\n",
"VAR_38 = VAR_42.split(':')\n",
"VAR_38 = self.configuration.iscsi_ip_address\n",
"VAR_22 = self.common.get_ports()['iSCSI']\n",
"if len(VAR_38) == 1:\n",
"VAR_39 = self.configuration.iscsi_port\n",
"for VAR_38, iscsi_info in VAR_22.iteritems():\n",
"VAR_21[VAR_42] = {'ip_port': VAR_2}\n",
"if len(VAR_38) == 2:\n",
"VAR_21[VAR_38] = {'ip_port': VAR_39}\n",
"if VAR_38 in VAR_21:\n",
"if self.configuration.iscsi_ip_address in VAR_21:\n",
"VAR_21[VAR_38[0]] = {'ip_port': VAR_38[1]}\n",
"VAR_40 = _(\"Invalid IP address format '%s'\") % VAR_42\n",
"VAR_39 = VAR_21[VAR_38]['ip_port']\n",
"if len(VAR_21) > 0:\n",
"VAR_1.warn(VAR_40)\n",
"self.iscsi_ips[VAR_38] = {'ip_port': VAR_39, 'nsp': iscsi_info['nsp'],\n 'iqn': iscsi_info['iqn']}\n",
"VAR_40 = _('string') % ', '.join(VAR_21)\n",
"if not len(self.iscsi_ips) > 0:\n",
"VAR_1.warn(VAR_40)\n",
"VAR_40 = _('At least one valid iSCSI IP address must be set.')\n",
"self.common.do_setup(VAR_6)\n"
] | [
"def do_setup(self, context):...\n",
"self.common = self._init_common()\n",
"self._check_flags()\n",
"self.iscsi_ips = {}\n",
"temp_iscsi_ip = {}\n",
"if len(self.configuration.hp3par_iscsi_ips) > 0:\n",
"for ip_addr in self.configuration.hp3par_iscsi_ips:\n",
"if self.configuration.iscsi_ip_address not in temp_iscsi_ip:\n",
"ip = ip_addr.split(':')\n",
"ip = self.configuration.iscsi_ip_address\n",
"iscsi_ports = self.common.get_ports()['iSCSI']\n",
"if len(ip) == 1:\n",
"ip_port = self.configuration.iscsi_port\n",
"for ip, iscsi_info in iscsi_ports.iteritems():\n",
"temp_iscsi_ip[ip_addr] = {'ip_port': DEFAULT_ISCSI_PORT}\n",
"if len(ip) == 2:\n",
"temp_iscsi_ip[ip] = {'ip_port': ip_port}\n",
"if ip in temp_iscsi_ip:\n",
"if self.configuration.iscsi_ip_address in temp_iscsi_ip:\n",
"temp_iscsi_ip[ip[0]] = {'ip_port': ip[1]}\n",
"msg = _(\"Invalid IP address format '%s'\") % ip_addr\n",
"ip_port = temp_iscsi_ip[ip]['ip_port']\n",
"if len(temp_iscsi_ip) > 0:\n",
"LOG.warn(msg)\n",
"self.iscsi_ips[ip] = {'ip_port': ip_port, 'nsp': iscsi_info['nsp'], 'iqn':\n iscsi_info['iqn']}\n",
"msg = _(\n \"Found invalid iSCSI IP address(s) in configuration option(s) hp3par_iscsi_ips or iscsi_ip_address '%s.'\"\n ) % ', '.join(temp_iscsi_ip)\n",
"if not len(self.iscsi_ips) > 0:\n",
"LOG.warn(msg)\n",
"msg = _('At least one valid iSCSI IP address must be set.')\n",
"self.common.do_setup(context)\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
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"For",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"For",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Expr'"
] |
[
"def FUNC_4(VAR_3, VAR_4=True):...\n",
"if VAR_4:\n",
"VAR_1 = 1\n",
"print(CLASS_0.MAYBE_FAIL + '?', VAR_3, CLASS_0.END)\n",
"print(CLASS_0.FAIL + '✘', VAR_3, CLASS_0.END)\n"
] | [
"def print_error(str, reliable=True):...\n",
"if reliable:\n",
"return_code = 1\n",
"print(c.MAYBE_FAIL + '?', str, c.END)\n",
"print(c.FAIL + '✘', str, c.END)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_11(self):...\n",
"for string in self.test_strings:\n",
"self.assertEqual(prepare_string_argument(string, 'WeIrD_O/S'), string)\n"
] | [
"def test_prepare_string_argument_unsupported(self):...\n",
"for string in self.test_strings:\n",
"self.assertEqual(prepare_string_argument(string, 'WeIrD_O/S'), string)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"For",
"Expr'"
] |
[
"def FUNC_5(self):...\n",
"self.driver._eql_execute = self.mox.CreateMock(self.driver._eql_execute)\n",
"VAR_1 = {'name': self.volume_name, 'size': 1}\n",
"self.driver._eql_execute('volume', 'select', VAR_1['name'], 'show')\n",
"self.mox.ReplayAll()\n",
"self.driver.ensure_export({}, VAR_1)\n"
] | [
"def test_ensure_export(self):...\n",
"self.driver._eql_execute = self.mox.CreateMock(self.driver._eql_execute)\n",
"volume = {'name': self.volume_name, 'size': 1}\n",
"self.driver._eql_execute('volume', 'select', volume['name'], 'show')\n",
"self.mox.ReplayAll()\n",
"self.driver.ensure_export({}, volume)\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_29(VAR_34):...\n",
"self.assertEqual(logging.WARNING, VAR_34)\n"
] | [
"def check(x):...\n",
"self.assertEqual(logging.WARNING, x)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def __unicode__(self):...\n",
"return unicode(self.nickname())\n"
] | [
"def __unicode__(self):...\n",
"return unicode(self.nickname())\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_9(VAR_2, VAR_17):...\n",
"VAR_2.cursor.execute('string' % (' AND %s' % VAR_17 if VAR_17 else ''))\n",
"VAR_22 = VAR_2.cursor.fetchall()\n",
"VAR_23 = []\n",
"for VAR_27 in VAR_22:\n",
"VAR_16, VAR_5, VAR_6, VAR_35, VAR_8, VAR_36, VAR_37, VAR_38, VAR_39 = VAR_27\n",
"return VAR_23\n",
"VAR_23.append({'id': VAR_16, 'sheet_id': VAR_5, 'student_id': VAR_6, 'time':\n VAR_35, 'files_path': VAR_8, 'primary_alias': VAR_36, 'grader': VAR_37,\n 'decipoints': VAR_38, 'status': VAR_39 if VAR_39 else 'Unbearbeitet'})\n"
] | [
"def get_full_sql(db, filter):...\n",
"db.cursor.execute(\n \"\"\"SELECT\n submission.id,\n submission.sheet_id,\n submission.student_id,\n submission.time,\n submission.files_path,\n student.primary_alias,\n grading_result.grader,\n grading_result.decipoints,\n grading_result.status\n FROM\n submission\n INNER JOIN student ON\n submission.student_id = student.id\n AND student.deleted IS NOT 1\n AND submission.deleted IS NOT 1\n %s\n LEFT OUTER JOIN grading_result ON\n submission.id = grading_result.submission_id\n ORDER BY submission.id DESC\n \"\"\"\n % (' AND %s' % filter if filter else ''))\n",
"rows = db.cursor.fetchall()\n",
"all_full = []\n",
"for row in rows:\n",
"(id, sheet_id, student_id, time, files_path, primary_alias, grader,\n decipoints, status) = row\n",
"return all_full\n",
"all_full.append({'id': id, 'sheet_id': sheet_id, 'student_id': student_id,\n 'time': time, 'files_path': files_path, 'primary_alias': primary_alias,\n 'grader': grader, 'decipoints': decipoints, 'status': status if status else\n 'Unbearbeitet'})\n"
] | [
0,
4,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Return'",
"Expr'"
] |
[
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"return self.obj.__name__\n"
] | [
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"return self.obj.__name__\n"
] | [
0,
0,
0
] | [
"Condition",
"Docstring",
"Return'"
] |
[
"def __init__(self, VAR_32):...\n",
"super(CLASS_1, self).__init__()\n",
"self.signal = VAR_32\n"
] | [
"def __init__(self, sig):...\n",
"super(MustExit, self).__init__()\n",
"self.signal = sig\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'"
] |
[
"def FUNC_7():...\n",
"VAR_9 = AnsibleModule(argument_spec=dict(login_user=dict(default='postgres'\n ), login_password=dict(default='', no_log=True), login_host=dict(\n default=''), login_unix_socket=dict(default=''), port=dict(default=\n '5432'), option=dict(required=True, aliases=['name', 'setting', 'guc',\n 'parameter']), value=dict(default=''), state=dict(default='present',\n choices=['absent', 'present'])), supports_check_mode=True)\n",
"if not VAR_6:\n",
"VAR_9.fail_json(msg='the python psycopg2 module is required')\n",
"VAR_4 = VAR_9.params['option']\n",
"VAR_5 = VAR_9.params['value']\n",
"VAR_10 = VAR_9.params['port']\n",
"VAR_11 = VAR_9.params['state']\n",
"VAR_12 = False\n",
"VAR_13 = {'login_host': 'host', 'login_user': 'user', 'login_password':\n 'password', 'port': 'port'}\n",
"VAR_14 = dict((VAR_13[k], v) for k, v in iteritems(VAR_9.params) if k in\n VAR_13 and v != '')\n",
"if 'host' not in VAR_14 or VAR_14['host'] == '' or VAR_14['host'\n",
"VAR_17 = True\n",
"VAR_17 = False\n",
"if VAR_17 and VAR_9.params['login_unix_socket'] != '':\n",
"VAR_14['host'] = VAR_9.params['login_unix_socket']\n",
"VAR_18 = psycopg2.connect(database='postgres', **kw)\n",
"VAR_19 = get_exception()\n",
"if FUNC_0(VAR_3, VAR_4):\n",
"VAR_19 = get_exception()\n",
"VAR_9.exit_json(VAR_12=changed, VAR_4=option)\n",
"if psycopg2.__version__ >= '2.4.2':\n",
"VAR_9.fail_json(msg='unable to connect to database: %s' % e)\n",
"VAR_9.warn('string' % VAR_4)\n",
"if FUNC_3(VAR_3, VAR_4):\n",
"VAR_9.fail_json(msg=str(e))\n",
"VAR_18.autocommit = True\n",
"VAR_18.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n",
"if VAR_9.check_mode:\n",
"VAR_9.warn('Option %s does not exist' % VAR_4)\n",
"VAR_19 = get_exception()\n",
"VAR_3 = VAR_18.cursor(cursor_factory=psycopg2.extras.DictCursor)\n",
"if VAR_11 == 'absent':\n",
"if VAR_11 == 'absent':\n",
"VAR_9.fail_json(msg='Database query failed: %s' % e)\n",
"VAR_12 = not FUNC_2(VAR_3, VAR_4)\n",
"if VAR_11 == 'present':\n",
"if VAR_11 == 'present':\n",
"VAR_12 = FUNC_4(VAR_3, VAR_4)\n",
"VAR_19 = get_exception()\n",
"VAR_9.exit_json(VAR_12=changed, VAR_4=option)\n",
"VAR_12 = not FUNC_6(VAR_3, VAR_4, VAR_5)\n",
"VAR_12 = FUNC_5(VAR_3, VAR_4, VAR_5)\n",
"VAR_19 = get_exception()\n",
"VAR_9.fail_json(msg=str(e))\n",
"VAR_9.fail_json(msg=str(e))\n"
] | [
"def main():...\n",
"module = AnsibleModule(argument_spec=dict(login_user=dict(default=\n 'postgres'), login_password=dict(default='', no_log=True), login_host=\n dict(default=''), login_unix_socket=dict(default=''), port=dict(default\n ='5432'), option=dict(required=True, aliases=['name', 'setting', 'guc',\n 'parameter']), value=dict(default=''), state=dict(default='present',\n choices=['absent', 'present'])), supports_check_mode=True)\n",
"if not postgresqldb_found:\n",
"module.fail_json(msg='the python psycopg2 module is required')\n",
"option = module.params['option']\n",
"value = module.params['value']\n",
"port = module.params['port']\n",
"state = module.params['state']\n",
"changed = False\n",
"params_map = {'login_host': 'host', 'login_user': 'user', 'login_password':\n 'password', 'port': 'port'}\n",
"kw = dict((params_map[k], v) for k, v in iteritems(module.params) if k in\n params_map and v != '')\n",
"if 'host' not in kw or kw['host'] == '' or kw['host'] == 'localhost':\n",
"is_localhost = True\n",
"is_localhost = False\n",
"if is_localhost and module.params['login_unix_socket'] != '':\n",
"kw['host'] = module.params['login_unix_socket']\n",
"db_connection = psycopg2.connect(database='postgres', **kw)\n",
"e = get_exception()\n",
"if option_ispreset(cursor, option):\n",
"e = get_exception()\n",
"module.exit_json(changed=changed, option=option)\n",
"if psycopg2.__version__ >= '2.4.2':\n",
"module.fail_json(msg='unable to connect to database: %s' % e)\n",
"module.warn(\n 'Option %s is preset, so it can only be set at initdb or before building from source code. For details, see postgresql.org/docs/current/static/runtime-config-preset.html'\n % option)\n",
"if option_exists(cursor, option):\n",
"module.fail_json(msg=str(e))\n",
"db_connection.autocommit = True\n",
"db_connection.set_isolation_level(psycopg2.extensions.\n ISOLATION_LEVEL_AUTOCOMMIT)\n",
"if module.check_mode:\n",
"module.warn('Option %s does not exist' % option)\n",
"e = get_exception()\n",
"cursor = db_connection.cursor(cursor_factory=psycopg2.extras.DictCursor)\n",
"if state == 'absent':\n",
"if state == 'absent':\n",
"module.fail_json(msg='Database query failed: %s' % e)\n",
"changed = not option_isdefault(cursor, option)\n",
"if state == 'present':\n",
"if state == 'present':\n",
"changed = option_reset(cursor, option)\n",
"e = get_exception()\n",
"module.exit_json(changed=changed, option=option)\n",
"changed = not option_matches(cursor, option, value)\n",
"changed = option_set(cursor, option, value)\n",
"e = get_exception()\n",
"module.fail_json(msg=str(e))\n",
"module.fail_json(msg=str(e))\n"
] | [
0,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
4,
0,
0,
4,
4,
4,
4,
0,
4,
4,
4,
4,
0,
4,
4,
0,
4,
4,
4,
0,
4,
0,
4,
4,
4,
0,
4,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def __init__(self, VAR_6, VAR_7=None):...\n",
"super().__init__(VAR_6, VAR_7)\n",
"self.type = 'ip6'\n"
] | [
"def __init__(self, name, display_name=None):...\n",
"super().__init__(name, display_name)\n",
"self.type = 'ip6'\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'"
] |
[
"def FUNC_0(*VAR_0, **VAR_1):...\n",
"VAR_2 = requests.Response()\n",
"VAR_2.status_code = 200\n",
"VAR_2._content_consumed = True\n",
"return VAR_2\n"
] | [
"def mock_import_repository_task(*args, **kwargs):...\n",
"resp = requests.Response()\n",
"resp.status_code = 200\n",
"resp._content_consumed = True\n",
"return resp\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_28(self, VAR_21):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_65 = [x[VAR_1] for x in self.get_path(VAR_21)]\n",
"return VAR_65\n"
] | [
"def listdir(self, path):...\n",
"\"\"\"docstring\"\"\"\n",
"names = [x[A_NAME] for x in self.get_path(path)]\n",
"return names\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Return'"
] |
[
"def __str__(self):...\n",
"return ' '.join(map(str, self))\n"
] | [
"def __str__(self):...\n",
"return ' '.join(map(str, self))\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_6(self):...\n",
"if VAR_101.user_is_loggedin and VAR_101.user.safe_karma >= g.discussion_karma_to_post:\n",
"return True\n",
"abort(403, 'forbidden')\n"
] | [
"def run(self):...\n",
"if c.user_is_loggedin and c.user.safe_karma >= g.discussion_karma_to_post:\n",
"return True\n",
"abort(403, 'forbidden')\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Expr'"
] |
[
"def FUNC_8(VAR_1):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_11 = block.sysfs_to_devpath(VAR_1)\n",
"LOG.debug('using mdadm.mdadm_stop on dev: %s', VAR_11)\n",
"mdadm.mdadm_stop(VAR_11)\n",
"for wait in VAR_0:\n",
"LOG.critical('Failed to stop mdadm device %s', VAR_1)\n",
"if mdadm.md_present(block.path_to_kname(VAR_11)):\n",
"if mdadm.md_present(block.path_to_kname(VAR_11)):\n",
"if os.path.exists('/proc/mdstat'):\n",
"time.sleep(wait)\n",
"LOG.debug('%s has been removed', VAR_11)\n",
"LOG.critical('/proc/mdstat:\\n%s', util.load_file('/proc/mdstat'))\n"
] | [
"def shutdown_mdadm(device):...\n",
"\"\"\"docstring\"\"\"\n",
"blockdev = block.sysfs_to_devpath(device)\n",
"LOG.debug('using mdadm.mdadm_stop on dev: %s', blockdev)\n",
"mdadm.mdadm_stop(blockdev)\n",
"for wait in MDADM_RELEASE_RETRIES:\n",
"LOG.critical('Failed to stop mdadm device %s', device)\n",
"if mdadm.md_present(block.path_to_kname(blockdev)):\n",
"if mdadm.md_present(block.path_to_kname(blockdev)):\n",
"if os.path.exists('/proc/mdstat'):\n",
"time.sleep(wait)\n",
"LOG.debug('%s has been removed', blockdev)\n",
"LOG.critical('/proc/mdstat:\\n%s', util.load_file('/proc/mdstat'))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Expr'",
"Expr'",
"For",
"Expr'",
"Condition",
"Condition",
"Condition",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_0():...\n",
"VAR_1 = config('cuckoo:cuckoo:machinery')\n",
"if config('routing:vpn:enabled'):\n",
"VAR_4 = config('routing:vpn:vpns')\n",
"VAR_4 = []\n",
"return {'machine': config('%s:%s:machines' % (VAR_1, VAR_1)), 'package':\n None, 'priority': 2, 'timeout': config('cuckoo:timeouts:default'),\n 'routing': {'route': config('routing:routing:route'), 'inetsim': config\n ('routing:inetsim:enabled'), 'tor': config('routing:tor:enabled'),\n 'vpns': VAR_4}, 'options': {'enable-services': False, 'enforce-timeout':\n False, 'full-memory-dump': config('cuckoo:cuckoo:memory_dump'),\n 'no-injection': False, 'process-memory-dump': True,\n 'simulated-human-interaction': True}}\n"
] | [
"def defaults():...\n",
"machinery = config('cuckoo:cuckoo:machinery')\n",
"if config('routing:vpn:enabled'):\n",
"vpns = config('routing:vpn:vpns')\n",
"vpns = []\n",
"return {'machine': config('%s:%s:machines' % (machinery, machinery)),\n 'package': None, 'priority': 2, 'timeout': config(\n 'cuckoo:timeouts:default'), 'routing': {'route': config(\n 'routing:routing:route'), 'inetsim': config('routing:inetsim:enabled'),\n 'tor': config('routing:tor:enabled'), 'vpns': vpns}, 'options': {\n 'enable-services': False, 'enforce-timeout': False, 'full-memory-dump':\n config('cuckoo:cuckoo:memory_dump'), 'no-injection': False,\n 'process-memory-dump': True, 'simulated-human-interaction': True}}\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_8(self):...\n",
"if not exists(self.directory):\n",
"self.checkout()\n",
"if not exists(self.directory + '/.svn'):\n",
"FUNC_1(self.directory, 'Subversion')\n",
"if self.has_local_edit():\n",
"VAR_0.warning(\"Directory '%s' contains local modifications\" % self.directory)\n",
"VAR_77, VAR_78 = (self.url.geturl().split('@') + [''])[:2]\n",
"if VAR_77 == self.url_from_checkout(VAR_2=False):\n",
"fork(['svn', 'up'] + (['-r' + VAR_78] if VAR_78 else []))\n",
"fork(['svn', 'switch', self.url.geturl()])\n"
] | [
"def update(self):...\n",
"if not exists(self.directory):\n",
"self.checkout()\n",
"if not exists(self.directory + '/.svn'):\n",
"not_a_project(self.directory, 'Subversion')\n",
"if self.has_local_edit():\n",
"logger.warning(\"Directory '%s' contains local modifications\" % self.directory)\n",
"target_base, target_rev = (self.url.geturl().split('@') + [''])[:2]\n",
"if target_base == self.url_from_checkout(include_commit=False):\n",
"fork(['svn', 'up'] + (['-r' + target_rev] if target_rev else []))\n",
"fork(['svn', 'switch', self.url.geturl()])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_5(self):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_4 = '/api/apps'\n",
"VAR_5 = self.client.post(VAR_4)\n",
"self.assertEqual(VAR_5.status_code, 201)\n",
"VAR_6 = VAR_5.data['id']\n",
"VAR_14 = {'username': 'autotest', 'app': VAR_6}\n",
"VAR_4 = '/api/hooks/builds'.format(**locals())\n",
"VAR_15 = {'web': 'node server.js', 'worker': 'node worker.js'}\n",
"VAR_16 = 'ecdff91c57a0b9ab82e89634df87e293d259a3aa'\n",
"VAR_7 = {'receive_user': 'autotest', 'receive_repo': VAR_6, 'image':\n '{app_id}:v2'.format(**locals()), 'sha': VAR_16, 'procfile': VAR_15}\n",
"self.assertIsNone(self.client.logout())\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_7), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_5.status_code, 403)\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_7), content_type=\n 'application/json', HTTP_X_DEIS_BUILDER_AUTH=settings.BUILDER_KEY)\n",
"self.assertEqual(VAR_5.status_code, 200)\n",
"self.assertIn('release', VAR_5.data)\n",
"self.assertIn('version', VAR_5.data['release'])\n",
"self.assertIn('domains', VAR_5.data)\n",
"self.assertTrue(self.client.login(VAR_8='autotest', VAR_9='password'))\n",
"VAR_4 = '/api/apps/{app_id}/builds'.format(**locals())\n",
"VAR_5 = self.client.get(VAR_4)\n",
"self.assertEqual(VAR_5.status_code, 200)\n",
"self.assertIn('results', VAR_5.data)\n",
"VAR_14 = VAR_5.data['results'][0]\n",
"self.assertEqual(VAR_14['sha'], VAR_16)\n",
"self.assertEqual(VAR_14['procfile'], VAR_15)\n",
"VAR_4 = '/api/apps/{app_id}/containers/web'.format(**locals())\n",
"VAR_5 = self.client.get(VAR_4)\n",
"self.assertEqual(VAR_5.status_code, 200)\n",
"self.assertEqual(len(VAR_5.data['results']), 1)\n",
"VAR_17 = VAR_5.data['results'][0]\n",
"self.assertEqual(VAR_17['type'], 'web')\n",
"self.assertEqual(VAR_17['num'], 1)\n"
] | [
"def test_build_hook_procfile(self):...\n",
"\"\"\"docstring\"\"\"\n",
"url = '/api/apps'\n",
"response = self.client.post(url)\n",
"self.assertEqual(response.status_code, 201)\n",
"app_id = response.data['id']\n",
"build = {'username': 'autotest', 'app': app_id}\n",
"url = '/api/hooks/builds'.format(**locals())\n",
"PROCFILE = {'web': 'node server.js', 'worker': 'node worker.js'}\n",
"SHA = 'ecdff91c57a0b9ab82e89634df87e293d259a3aa'\n",
"body = {'receive_user': 'autotest', 'receive_repo': app_id, 'image':\n '{app_id}:v2'.format(**locals()), 'sha': SHA, 'procfile': PROCFILE}\n",
"self.assertIsNone(self.client.logout())\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 403)\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json', HTTP_X_DEIS_BUILDER_AUTH=settings.BUILDER_KEY)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertIn('release', response.data)\n",
"self.assertIn('version', response.data['release'])\n",
"self.assertIn('domains', response.data)\n",
"self.assertTrue(self.client.login(username='autotest', password='password'))\n",
"url = '/api/apps/{app_id}/builds'.format(**locals())\n",
"response = self.client.get(url)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertIn('results', response.data)\n",
"build = response.data['results'][0]\n",
"self.assertEqual(build['sha'], SHA)\n",
"self.assertEqual(build['procfile'], PROCFILE)\n",
"url = '/api/apps/{app_id}/containers/web'.format(**locals())\n",
"response = self.client.get(url)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertEqual(len(response.data['results']), 1)\n",
"container = response.data['results'][0]\n",
"self.assertEqual(container['type'], 'web')\n",
"self.assertEqual(container['num'], 1)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
5,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"@api.public...\n",
"VAR_6.assertEqual(model.Anonymous, api.get_current_identity())\n",
"self.response.write('OK')\n"
] | [
"@api.public...\n",
"test.assertEqual(model.Anonymous, api.get_current_identity())\n",
"self.response.write('OK')\n"
] | [
0,
0,
0
] | [
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_10(self):...\n",
"VAR_4 = '/api/apps'\n",
"VAR_5 = self.client.post(VAR_4)\n",
"self.assertEqual(VAR_5.status_code, 201)\n",
"VAR_6 = VAR_5.data['id']\n",
"VAR_4 = '/api/apps/{app_id}/containers'.format(**locals())\n",
"VAR_5 = self.client.get(VAR_4)\n",
"self.assertEqual(VAR_5.status_code, 200)\n",
"self.assertEqual(len(VAR_5.data['results']), 0)\n",
"VAR_4 = '/api/apps/{app_id}/builds'.format(**locals())\n",
"VAR_8 = {'image': 'autotest/example', 'sha': 'a' * 40, 'procfile': json.\n dumps({'web': 'node server.js', 'worker': 'node worker.js'})}\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_8), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_5.status_code, 201)\n",
"VAR_4 = '/api/apps/{app_id}/scale'.format(**locals())\n",
"VAR_8 = {'web': -1}\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_8), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_5.status_code, 400)\n",
"VAR_4 = '/api/apps/{app_id}/scale'.format(**locals())\n",
"VAR_8 = {'web': 'one'}\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_8), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_5.status_code, 400)\n",
"VAR_4 = '/api/apps/{app_id}/scale'.format(**locals())\n",
"VAR_8 = {'web': [1]}\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_8), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_5.status_code, 400)\n",
"VAR_4 = '/api/apps/{app_id}/scale'.format(**locals())\n",
"VAR_8 = {'web': 1}\n",
"VAR_5 = self.client.post(VAR_4, json.dumps(VAR_8), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_5.status_code, 204)\n"
] | [
"def test_container_scale_errors(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}/containers'.format(**locals())\n",
"response = self.client.get(url)\n",
"self.assertEqual(response.status_code, 200)\n",
"self.assertEqual(len(response.data['results']), 0)\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}/scale'.format(**locals())\n",
"body = {'web': -1}\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 400)\n",
"url = '/api/apps/{app_id}/scale'.format(**locals())\n",
"body = {'web': 'one'}\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 400)\n",
"url = '/api/apps/{app_id}/scale'.format(**locals())\n",
"body = {'web': [1]}\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 400)\n",
"url = '/api/apps/{app_id}/scale'.format(**locals())\n",
"body = {'web': 1}\n",
"response = self.client.post(url, json.dumps(body), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 204)\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
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_1(self, VAR_1):...\n",
"return self.properties\n"
] | [
"def _fake_get_iscsi_properties(self, volume):...\n",
"return self.properties\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_13(self):...\n",
"self.run_test_case(self.scenario.delete_load_balancer(), max_retries=5)\n"
] | [
"def test_y_delete_load_balancer(self):...\n",
"self.run_test_case(self.scenario.delete_load_balancer(), max_retries=5)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_17(self):...\n",
"VAR_7 = [('x', 'y'), (1, 2)]\n",
"VAR_8 = [('key', 'filename', 'file data')]\n",
"VAR_9, VAR_10 = url_helper.EncodeMultipartFormData()\n",
"self.assertTrue(VAR_9.startswith('multipart/form-data; boundary='))\n",
"self.assertEqual('', VAR_10)\n",
"VAR_9, VAR_10 = url_helper.EncodeMultipartFormData(VAR_7=fields)\n",
"self.assertTrue(VAR_9.startswith('multipart/form-data; boundary='))\n",
"self.assertTrue('name=\"x\"\\r\\n\\r\\ny' in VAR_10, VAR_10)\n",
"self.assertTrue('name=\"1\"\\r\\n\\r\\n2' in VAR_10, VAR_10)\n",
"VAR_9, VAR_10 = url_helper.EncodeMultipartFormData(VAR_8=files)\n",
"self.assertTrue(VAR_9.startswith('multipart/form-data; boundary='))\n",
"self.assertTrue('name=\"key\"; filename=\"filename\"' in VAR_10, VAR_10)\n",
"self.assertTrue('file data' in VAR_10, VAR_10)\n",
"VAR_9, VAR_10 = url_helper.EncodeMultipartFormData(VAR_7=fields, VAR_8=files)\n",
"self.assertTrue(VAR_9.startswith('multipart/form-data; boundary='))\n",
"self.assertTrue('name=\"x\"\\r\\n\\r\\ny' in VAR_10, VAR_10)\n",
"self.assertTrue('name=\"1\"\\r\\n\\r\\n2' in VAR_10, VAR_10)\n"
] | [
"def testEncodeMultipartFormData(self):...\n",
"fields = [('x', 'y'), (1, 2)]\n",
"files = [('key', 'filename', 'file data')]\n",
"content_type, body = url_helper.EncodeMultipartFormData()\n",
"self.assertTrue(content_type.startswith('multipart/form-data; boundary='))\n",
"self.assertEqual('', body)\n",
"content_type, body = url_helper.EncodeMultipartFormData(fields=fields)\n",
"self.assertTrue(content_type.startswith('multipart/form-data; boundary='))\n",
"self.assertTrue('name=\"x\"\\r\\n\\r\\ny' in body, body)\n",
"self.assertTrue('name=\"1\"\\r\\n\\r\\n2' in body, body)\n",
"content_type, body = url_helper.EncodeMultipartFormData(files=files)\n",
"self.assertTrue(content_type.startswith('multipart/form-data; boundary='))\n",
"self.assertTrue('name=\"key\"; filename=\"filename\"' in body, body)\n",
"self.assertTrue('file data' in body, body)\n",
"content_type, body = url_helper.EncodeMultipartFormData(fields=fields,\n files=files)\n",
"self.assertTrue(content_type.startswith('multipart/form-data; boundary='))\n",
"self.assertTrue('name=\"x\"\\r\\n\\r\\ny' in body, body)\n",
"self.assertTrue('name=\"1\"\\r\\n\\r\\n2' in body, body)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.