lines
sequencelengths 1
444
| raw_lines
sequencelengths 1
444
| label
sequencelengths 1
444
| type
sequencelengths 1
444
|
|---|---|---|---|
[
"def FUNC_6(self, VAR_33):...\n",
"VAR_78 = []\n",
"for v in self.splitter.split(VAR_33):\n",
"VAR_21 = self.id_re.match(v)\n",
"return VAR_78\n",
"if VAR_21:\n",
"VAR_108 = CLASS_5(None, False).run(VAR_21.group(1))\n",
"if VAR_108:\n",
"VAR_78.append(VAR_108)\n"
] | [
"def run(self, val):...\n",
"res = []\n",
"for v in self.splitter.split(val):\n",
"link_id = self.id_re.match(v)\n",
"return res\n",
"if link_id:\n",
"l = VLink(None, False).run(link_id.group(1))\n",
"if l:\n",
"res.append(l)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"For",
"Assign'",
"Return'",
"Condition",
"Assign'",
"Condition",
"Expr'"
] |
[
"def FUNC_0(VAR_2):...\n",
"if VAR_2.user.is_authenticated():\n",
"VAR_33 = VAR_2.GET.get('next', reverse('home'))\n",
"VAR_1.error('login() - got anonymous user: %s' % VAR_2.META)\n",
"return HttpResponseRedirect(VAR_33)\n",
"return HttpResponseServerError(\n 'Internet Server error. Please contact %s for assistance.' % VAR_0)\n"
] | [
"def login(request):...\n",
"if request.user.is_authenticated():\n",
"next_url = request.GET.get('next', reverse('home'))\n",
"logger.error('login() - got anonymous user: %s' % request.META)\n",
"return HttpResponseRedirect(next_url)\n",
"return HttpResponseServerError(\n 'Internet Server error. Please contact %s for assistance.' % BDR_EMAIL)\n"
] | [
0,
0,
6,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Expr'",
"Return'",
"Return'"
] |
[
"def FUNC_2(self):...\n",
"return sqlite\n"
] | [
"def dbapiModule(self):...\n",
"return sqlite\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_11(self, VAR_9, *VAR_13, **VAR_14):...\n",
"VAR_14['partial'] = True\n",
"return self.update(VAR_9, *VAR_13, **kwargs)\n"
] | [
"def partial_update(self, request, *args, **kwargs):...\n",
"kwargs['partial'] = True\n",
"return self.update(request, *args, **kwargs)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def __init__(self, VAR_25=settings.CLICKHOUSE_SERVER.split(':')[0], VAR_26=...\n",
"self.host = VAR_25\n",
"self.port = VAR_26\n",
"self.connect_timeout = VAR_27\n",
"self.send_receive_timeout = VAR_28\n",
"self.client_settings = VAR_30\n",
"self.metrics = VAR_31\n",
"self.pool = queue.LifoQueue(VAR_29)\n",
"for _ in range(VAR_29):\n",
"self.pool.put(None)\n"
] | [
"def __init__(self, host=settings.CLICKHOUSE_SERVER.split(':')[0], port=int(...\n",
"self.host = host\n",
"self.port = port\n",
"self.connect_timeout = connect_timeout\n",
"self.send_receive_timeout = send_receive_timeout\n",
"self.client_settings = client_settings\n",
"self.metrics = metrics\n",
"self.pool = queue.LifoQueue(max_pool_size)\n",
"for _ in range(max_pool_size):\n",
"self.pool.put(None)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Expr'"
] |
[
"def FUNC_13(self, *VAR_13, **VAR_14):...\n",
"for VAR_9 in VAR_13:\n",
"self._set_log_item(VAR_9)\n",
"for VAR_10, VAR_9 in VAR_14.items():\n",
"self._set_log_item(VAR_9, VAR_10=name)\n"
] | [
"def set_log(self, *logs, **kwlogs):...\n",
"for item in logs:\n",
"self._set_log_item(item)\n",
"for name, item in kwlogs.items():\n",
"self._set_log_item(item, name=name)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"For",
"Expr'",
"For",
"Expr'"
] |
[
"def FUNC_8(self):...\n",
"url_helper.urllib2.urlopen(mox.IgnoreArg(), mox.IgnoreArg(), timeout=mox.\n IgnoreArg()).AndRaise(urllib2.URLError('url'))\n",
"self._mox.ReplayAll()\n",
"self.assertIsNone(url_helper.UrlOpen('url', max_tries=1))\n",
"self._mox.VerifyAll()\n"
] | [
"def testUrlOpenFailure(self):...\n",
"url_helper.urllib2.urlopen(mox.IgnoreArg(), mox.IgnoreArg(), timeout=mox.\n IgnoreArg()).AndRaise(urllib2.URLError('url'))\n",
"self._mox.ReplayAll()\n",
"self.assertIsNone(url_helper.UrlOpen('url', max_tries=1))\n",
"self._mox.VerifyAll()\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def __init__(self, VAR_3):...\n",
"\"\"\"docstring\"\"\"\n",
"super(CLASS_0, self).__init__()\n",
"os.makedirs(path.join(VAR_1, DATABASES_FOLDER_NAME), exist_ok=True)\n",
"self.filename = path.join(VAR_1, DATABASES_FOLDER_NAME, VAR_3 + '.db')\n",
"self.lock = Lock()\n",
"VAR_13 = {'type': 0, 'meta': 'str', 'path': 'str', 'mod_time': 0, 'file_id':\n 'str'}\n",
"if VAR_13:\n",
"if path.isfile(self.filename):\n",
"for i in VAR_13.keys():\n",
"self.createTable(VAR_13)\n",
"self._addColumn(i, VAR_13[i])\n"
] | [
"def __init__(self, filename):...\n",
"\"\"\"docstring\"\"\"\n",
"super(FileDB, self).__init__()\n",
"os.makedirs(path.join(SCRIPT_FOLDER, DATABASES_FOLDER_NAME), exist_ok=True)\n",
"self.filename = path.join(SCRIPT_FOLDER, DATABASES_FOLDER_NAME, filename +\n '.db')\n",
"self.lock = Lock()\n",
"initial = {'type': 0, 'meta': 'str', 'path': 'str', 'mod_time': 0,\n 'file_id': 'str'}\n",
"if initial:\n",
"if path.isfile(self.filename):\n",
"for i in initial.keys():\n",
"self.createTable(initial)\n",
"self._addColumn(i, initial[i])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"For",
"Expr'",
"Expr'"
] |
[
"def FUNC_11(VAR_16, VAR_17, VAR_18=True):...\n",
"if isinstance(VAR_16, CLASS_1):\n",
"VAR_16.flags[VAR_17] = VAR_18\n",
"if FUNC_10(VAR_16):\n",
"return VAR_16\n",
"VAR_16 = CLASS_1(VAR_16)\n",
"return [VAR_19(v, VAR_17, VAR_18=flag_value) for v in VAR_16]\n",
"VAR_16.flags[VAR_17] = VAR_18\n",
"return VAR_16\n"
] | [
"def flag(value, flag_type, flag_value=True):...\n",
"if isinstance(value, AnnotatedString):\n",
"value.flags[flag_type] = flag_value\n",
"if not_iterable(value):\n",
"return value\n",
"value = AnnotatedString(value)\n",
"return [flag(v, flag_type, flag_value=flag_value) for v in value]\n",
"value.flags[flag_type] = flag_value\n",
"return value\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Condition",
"Return'",
"Assign'",
"Return'",
"Assign'",
"Return'"
] |
[
"def __init__(self, VAR_7, VAR_57, VAR_58=True, **VAR_16):...\n",
"self.nav = VAR_57\n",
"self.remember = VAR_58\n",
"VAR_7 = VAR_57.get_param, VAR_7\n",
"CLASS_0.__init__(self, VAR_7, **kw)\n"
] | [
"def __init__(self, param, menu_cls, remember=True, **kw):...\n",
"self.nav = menu_cls\n",
"self.remember = remember\n",
"param = menu_cls.get_param, param\n",
"Validator.__init__(self, param, **kw)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_4(self, VAR_10, VAR_9):...\n",
"VAR_0.info('Updating table c{} in the MySQL database'.format(VAR_9))\n",
"VAR_0.info('Requesting for MySQL connection')\n",
"VAR_11 = self.get_connection()\n",
"VAR_18 = VAR_11.cursor()\n",
"for l in VAR_10:\n",
"if not isinstance(l, Listing):\n",
"return 0\n",
"VAR_0.error('TypeError: Expected a Listing instance')\n",
"VAR_0.debug('Generating SQL command')\n",
"VAR_0.error('Skipping this listing')\n",
"VAR_19 = self.gen_sql_insert(l, VAR_9)\n",
"if VAR_19 == -1:\n",
"VAR_0.error('Skipping the listing')\n",
"VAR_0.debug('Executing SQL command')\n",
"VAR_11.rollback()\n",
"VAR_18.execute(VAR_19)\n",
"VAR_0.error('Failed to add a listing to table c{:d}'.format(VAR_9))\n",
"VAR_0.debug('Committing changes to the database')\n",
"VAR_0.error('Rolled back the database changes')\n",
"VAR_11.commit()\n",
"VAR_0.info('Successfully added a listing to table c{:d}'.format(VAR_9))\n"
] | [
"def update_table(self, listings, cat_id):...\n",
"logger.info('Updating table c{} in the MySQL database'.format(cat_id))\n",
"logger.info('Requesting for MySQL connection')\n",
"db = self.get_connection()\n",
"cursor = db.cursor()\n",
"for l in listings:\n",
"if not isinstance(l, Listing):\n",
"return 0\n",
"logger.error('TypeError: Expected a Listing instance')\n",
"logger.debug('Generating SQL command')\n",
"logger.error('Skipping this listing')\n",
"sql = self.gen_sql_insert(l, cat_id)\n",
"if sql == -1:\n",
"logger.error('Skipping the listing')\n",
"logger.debug('Executing SQL command')\n",
"db.rollback()\n",
"cursor.execute(sql)\n",
"logger.error('Failed to add a listing to table c{:d}'.format(cat_id))\n",
"logger.debug('Committing changes to the database')\n",
"logger.error('Rolled back the database changes')\n",
"db.commit()\n",
"logger.info('Successfully added a listing to table c{:d}'.format(cat_id))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
4,
0,
4,
0,
0,
0,
0,
4,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"For",
"Condition",
"Return'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_8(VAR_13, VAR_16):...\n",
"VAR_35 = subprocess.Popen([VAR_13], stdin=subprocess.PIPE, VAR_36=\n subprocess.PIPE, VAR_37=subprocess.PIPE)\n",
"VAR_36, VAR_37 = VAR_35.communicate(json.dumps(VAR_16))\n",
"VAR_35.wait()\n",
"if VAR_35.returncode != 0:\n",
"return VAR_36\n"
] | [
"def render_executable(path, config):...\n",
"p = subprocess.Popen([path], stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n",
"stdout, stderr = p.communicate(json.dumps(config))\n",
"p.wait()\n",
"if p.returncode != 0:\n",
"return stdout\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Return'"
] |
[
"def FUNC_20():...\n",
"VAR_61 = Popen(['git', 'ls-tree', '-r', '--name-only', 'HEAD'], stdout=PIPE,\n VAR_37=env)\n",
"VAR_62 = VAR_61.communicate()[0]\n",
"if VAR_61.returncode != 0 or not VAR_62.strip():\n",
"return None\n",
"return [e.strip() for e in VAR_62.splitlines() if os.path.exists(e)]\n"
] | [
"def tracked_files():...\n",
"p = Popen(['git', 'ls-tree', '-r', '--name-only', 'HEAD'], stdout=PIPE, env=env\n )\n",
"out = p.communicate()[0]\n",
"if p.returncode != 0 or not out.strip():\n",
"return None\n",
"return [e.strip() for e in out.splitlines() if os.path.exists(e)]\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Return'"
] |
[
"def __init__(VAR_39, VAR_40, VAR_41, VAR_42, VAR_48, VAR_43, VAR_44, VAR_45,...\n",
"VAR_39.returncode = None\n",
"VAR_39._out_file = VAR_7.path.join(self.root_dir, 'work',\n 'task_runner_out.json')\n",
"VAR_6 = [sys.executable, bot_main.THIS_FILE, 'task_runner',\n '--swarming-server', VAR_3, '--in-file', VAR_7.path.join(self.root_dir,\n 'work', 'task_runner_in.json'), '--out-file', VAR_39._out_file,\n '--cost-usd-hour', '3600.0', '--start', '100.0', '--min-free-space',\n str(int((os_utilities.get_min_free_space(bot_main.THIS_FILE) + 250.0) *\n 1024 * 1024))]\n",
"self.assertEqual(VAR_6, VAR_40)\n",
"self.assertEqual(True, VAR_41)\n",
"self.assertEqual(self.bot.base_dir, VAR_42)\n",
"self.assertEqual('24', VAR_48['SWARMING_TASK_ID'])\n",
"self.assertTrue(VAR_43)\n",
"self.assertEqual(subprocess42.STDOUT, VAR_44)\n",
"self.assertEqual(subprocess42.PIPE, VAR_45)\n",
"self.assertEqual(sys.platform != 'win32', VAR_46)\n"
] | [
"def __init__(self2, cmd, detached, cwd, env, stdout, stderr, stdin, close_fds):...\n",
"self2.returncode = None\n",
"self2._out_file = os.path.join(self.root_dir, 'work', 'task_runner_out.json')\n",
"expected = [sys.executable, bot_main.THIS_FILE, 'task_runner',\n '--swarming-server', url, '--in-file', os.path.join(self.root_dir,\n 'work', 'task_runner_in.json'), '--out-file', self2._out_file,\n '--cost-usd-hour', '3600.0', '--start', '100.0', '--min-free-space',\n str(int((os_utilities.get_min_free_space(bot_main.THIS_FILE) + 250.0) *\n 1024 * 1024))]\n",
"self.assertEqual(expected, cmd)\n",
"self.assertEqual(True, detached)\n",
"self.assertEqual(self.bot.base_dir, cwd)\n",
"self.assertEqual('24', env['SWARMING_TASK_ID'])\n",
"self.assertTrue(stdout)\n",
"self.assertEqual(subprocess42.STDOUT, stderr)\n",
"self.assertEqual(subprocess42.PIPE, stdin)\n",
"self.assertEqual(sys.platform != 'win32', close_fds)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_6(self):...\n",
"return True\n"
] | [
"def Done(self):...\n",
"return True\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_40(self):...\n",
""
] | [
"def _update_sortkey(self):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_0(VAR_3):...\n",
"if not VAR_3:\n",
"return VAR_3\n",
"if VAR_1.match(VAR_3):\n",
"return VAR_3\n",
"return u'{}`{}`'.format(*VAR_2.match(VAR_3).groups())\n"
] | [
"def escape_col(col):...\n",
"if not col:\n",
"return col\n",
"if ESCAPE_RE.match(col):\n",
"return col\n",
"return u'{}`{}`'.format(*NEGATE_RE.match(col).groups())\n"
] | [
0,
0,
0,
4,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_1(VAR_0=None, VAR_1=None):...\n",
"\"\"\"docstring\"\"\"\n",
"if VAR_0 is None:\n",
"VAR_0 = active_view()\n",
"if not get_settings(VAR_0, 'anaconda_go_linting', True):\n",
"return\n",
"if VAR_0.file_name() in anaconda_sublime.ANACONDA['DISABLED']:\n",
"anaconda_sublime.erase_lint_marks(VAR_0)\n",
"VAR_2 = FUNC_4(VAR_0)\n",
"return\n",
"VAR_3 = {'vid': VAR_0.id(), 'code': VAR_0.substr(st3_sublime.Region(0,\n VAR_0.size())), 'settings': VAR_2, 'filepath': VAR_0.file_name(),\n 'method': 'fast_lint', 'handler': 'anaGonda', 'go_env': {'GOROOT': go.\n GOROOT, 'GOPATH': go.GOPATH, 'CGO_ENABLED': go.CGO_ENABLED}}\n",
"VAR_4 = partial(anaconda_sublime.parse_results, **dict(code='go'))\n",
"if VAR_1 is None:\n",
"Worker().execute(Callback(on_success=callback), **data)\n",
"Worker().execute(Callback(partial(VAR_1, VAR_4)), **data)\n"
] | [
"def fast_linters(view=None, hook=None):...\n",
"\"\"\"docstring\"\"\"\n",
"if view is None:\n",
"view = active_view()\n",
"if not get_settings(view, 'anaconda_go_linting', True):\n",
"return\n",
"if view.file_name() in anaconda_sublime.ANACONDA['DISABLED']:\n",
"anaconda_sublime.erase_lint_marks(view)\n",
"settings = _get_settings(view)\n",
"return\n",
"data = {'vid': view.id(), 'code': view.substr(st3_sublime.Region(0, view.\n size())), 'settings': settings, 'filepath': view.file_name(), 'method':\n 'fast_lint', 'handler': 'anaGonda', 'go_env': {'GOROOT': go.GOROOT,\n 'GOPATH': go.GOPATH, 'CGO_ENABLED': go.CGO_ENABLED}}\n",
"callback = partial(anaconda_sublime.parse_results, **dict(code='go'))\n",
"if hook is None:\n",
"Worker().execute(Callback(on_success=callback), **data)\n",
"Worker().execute(Callback(partial(hook, callback)), **data)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Assign'",
"Condition",
"Return'",
"Condition",
"Expr'",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_6(self):...\n",
"if not (VAR_101.user_is_loggedin and VAR_101.site.is_moderator(VAR_101.user\n",
"abort(403, 'forbidden')\n"
] | [
"def run(self):...\n",
"if not (c.user_is_loggedin and c.site.is_moderator(c.user) or c.user_is_admin):\n",
"abort(403, 'forbidden')\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Expr'"
] |
[
"def FUNC_17(self, VAR_14):...\n",
""
] | [
"def is_relation(self, col_name):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def __str__(self):...\n",
"VAR_23 = '{type}: {from_to_url}'\n",
"if self.redirect_type in ['prefix', 'page', 'exact']:\n",
"return VAR_23.format(type=self.get_redirect_type_display(), from_to_url=\n self.get_from_to_url_display())\n",
"return ugettext('Redirect: {}'.format(self.get_redirect_type_display()))\n"
] | [
"def __str__(self):...\n",
"redirect_text = '{type}: {from_to_url}'\n",
"if self.redirect_type in ['prefix', 'page', 'exact']:\n",
"return redirect_text.format(type=self.get_redirect_type_display(),\n from_to_url=self.get_from_to_url_display())\n",
"return ugettext('Redirect: {}'.format(self.get_redirect_type_display()))\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_0(self, VAR_25, VAR_26):...\n",
"self._logger.info('Got Tribler core error: %s' % VAR_25)\n",
"if VAR_25 == QNetworkReply.ConnectionRefusedError:\n",
"if self.failed_attempts == 40:\n",
"self.failed_attempts += 1\n",
"if VAR_26:\n",
"self.connect_timer = QTimer()\n",
"self.connect_timer.setSingleShot(True)\n",
"self.connect_timer.timeout.connect(self.connect)\n",
"self.connect_timer.start(500)\n"
] | [
"def on_error(self, error, reschedule_on_err):...\n",
"self._logger.info('Got Tribler core error: %s' % error)\n",
"if error == QNetworkReply.ConnectionRefusedError:\n",
"if self.failed_attempts == 40:\n",
"self.failed_attempts += 1\n",
"if reschedule_on_err:\n",
"self.connect_timer = QTimer()\n",
"self.connect_timer.setSingleShot(True)\n",
"self.connect_timer.timeout.connect(self.connect)\n",
"self.connect_timer.start(500)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Condition",
"Condition",
"AugAssign'",
"Condition",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_38(VAR_65, VAR_66):...\n",
"VAR_79 = ElementTree.parse(VAR_66).getroot()\n",
"if VAR_79.tag != 'plugin':\n",
"return VAR_79.find('name').text\n"
] | [
"def process_info_file(cp_elem, info_file):...\n",
"plugin_info = ElementTree.parse(info_file).getroot()\n",
"if plugin_info.tag != 'plugin':\n",
"return plugin_info.find('name').text\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Return'"
] |
[
"def FUNC_4(self):...\n",
"if self.redirected_to is None:\n",
"return None\n",
"VAR_14 = self.redirected_to.split('?')\n",
"if len(VAR_14) != 2:\n",
"VAR_0.warning(\"Redirected to an unexpected page: `%s'\", self.redirected_to)\n",
"VAR_20 = decrypt_number(VAR_14[-1])\n",
"VAR_0.warning(\"Unable to decrypt submission id from page: `%s'\", self.\n redirected_to)\n",
"return VAR_20\n",
"return None\n",
"return None\n"
] | [
"def get_submission_id(self):...\n",
"if self.redirected_to is None:\n",
"return None\n",
"p = self.redirected_to.split('?')\n",
"if len(p) != 2:\n",
"logger.warning(\"Redirected to an unexpected page: `%s'\", self.redirected_to)\n",
"submission_id = decrypt_number(p[-1])\n",
"logger.warning(\"Unable to decrypt submission id from page: `%s'\", self.\n redirected_to)\n",
"return submission_id\n",
"return None\n",
"return None\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Expr'",
"Return'",
"Return'",
"Return'"
] |
[
"async def FUNC_2():...\n",
""
] | [
"async def is_connect_db():...\n",
""
] | [
0,
0
] | [
"AsyncFunctionDef'",
"Condition"
] |
[
"def FUNC_2(VAR_15, VAR_2, VAR_3='text', VAR_4=bconfig....\n",
"\"\"\"docstring\"\"\"\n",
"VAR_43 = reader.get_cache(VAR_2)\n",
"if not VAR_43:\n",
"reader.set_cache(VAR_2, reader.get_regular_expressions(VAR_2, rebuild=\n rebuild_cache, VAR_7=no_cache))\n",
"VAR_44 = VAR_43[0]\n",
"VAR_43 = reader.get_cache(VAR_2)\n",
"VAR_45 = VAR_43[1]\n",
"VAR_15 = normalizer.cut_references(VAR_15)\n",
"VAR_17 = normalizer.normalize_fulltext('\\n'.join(VAR_15))\n",
"if VAR_6 == 'partial':\n",
"VAR_17 = FUNC_26(VAR_17)\n",
"VAR_22 = None\n",
"if VAR_8:\n",
"VAR_22 = FUNC_6(VAR_44, VAR_45, VAR_17)\n",
"VAR_23 = {}\n",
"if VAR_11:\n",
"VAR_23 = FUNC_5(VAR_17)\n",
"VAR_20 = FUNC_3(VAR_44, VAR_17)\n",
"VAR_21 = FUNC_4(VAR_45, VAR_17, VAR_20)\n",
"if VAR_10:\n",
"VAR_20 = FUNC_22(FUNC_20(VAR_20))\n",
"VAR_20 = FUNC_22(VAR_20)\n",
"VAR_21 = FUNC_20(VAR_21)\n",
"return FUNC_7(VAR_20, VAR_21, VAR_2, VAR_22, VAR_23, VAR_3, VAR_4, VAR_5,\n VAR_10)\n"
] | [
"def get_keywords_from_text(text_lines, taxonomy_name, output_mode='text',...\n",
"\"\"\"docstring\"\"\"\n",
"cache = reader.get_cache(taxonomy_name)\n",
"if not cache:\n",
"reader.set_cache(taxonomy_name, reader.get_regular_expressions(\n taxonomy_name, rebuild=rebuild_cache, no_cache=no_cache))\n",
"_skw = cache[0]\n",
"cache = reader.get_cache(taxonomy_name)\n",
"_ckw = cache[1]\n",
"text_lines = normalizer.cut_references(text_lines)\n",
"fulltext = normalizer.normalize_fulltext('\\n'.join(text_lines))\n",
"if match_mode == 'partial':\n",
"fulltext = _get_partial_text(fulltext)\n",
"author_keywords = None\n",
"if with_author_keywords:\n",
"author_keywords = extract_author_keywords(_skw, _ckw, fulltext)\n",
"acronyms = {}\n",
"if extract_acronyms:\n",
"acronyms = extract_abbreviations(fulltext)\n",
"single_keywords = extract_single_keywords(_skw, fulltext)\n",
"composite_keywords = extract_composite_keywords(_ckw, fulltext, single_keywords\n )\n",
"if only_core_tags:\n",
"single_keywords = clean_before_output(_filter_core_keywors(single_keywords))\n",
"single_keywords = clean_before_output(single_keywords)\n",
"composite_keywords = _filter_core_keywors(composite_keywords)\n",
"return get_keywords_output(single_keywords, composite_keywords,\n taxonomy_name, author_keywords, acronyms, output_mode, output_limit,\n spires, only_core_tags)\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
] | [
"Condition",
"Docstring",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_20(self, VAR_16):...\n",
"return self.meta.get_field(VAR_16).options\n"
] | [
"def get_table_field_doctype(self, fieldname):...\n",
"return self.meta.get_field(fieldname).options\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_0():...\n",
"VAR_13 = VAR_0.path.dirname(VAR_0.path.abspath(__file__))\n",
"return VAR_0.path.join(VAR_13, 'server/ycmd.py')\n"
] | [
"def _PathToServerScript():...\n",
"dir_of_current_script = os.path.dirname(os.path.abspath(__file__))\n",
"return os.path.join(dir_of_current_script, 'server/ycmd.py')\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_2(self):...\n",
"VAR_14 = utils.GetUnusedLocalhostPort()\n",
"self._temp_options_filename = options_file.name\n",
"json.dump(dict(self._user_options), options_file)\n",
"options_file.flush()\n",
"VAR_21 = [utils.PathToPythonInterpreter(), FUNC_0(), '--port={0}'.format(\n VAR_14), '--options_file={0}'.format(options_file.name), '--log={0}'.\n format(self._user_options['server_log_level']),\n '--idle_suicide_seconds={0}'.format(VAR_4)]\n",
"if not self._user_options['server_use_vim_stdout']:\n",
"VAR_26 = VAR_0.path.join(utils.PathToTempDir(), 'server_{port}_{std}.log')\n",
"self._server_popen = utils.SafePopen(VAR_21, stdout=PIPE, stderr=PIPE)\n",
"self._server_stdout = VAR_26.format(port=server_port, std='stdout')\n",
"BaseRequest.server_location = 'http://localhost:' + str(VAR_14)\n",
"self._server_stderr = VAR_26.format(port=server_port, std='stderr')\n",
"self._NotifyUserIfServerCrashed()\n",
"VAR_21.append('--stdout={0}'.format(self._server_stdout))\n",
"VAR_21.append('--stderr={0}'.format(self._server_stderr))\n",
"if self._user_options['server_keep_logfiles']:\n",
"VAR_21.append('--keep_logfiles')\n"
] | [
"def _SetupServer(self):...\n",
"server_port = utils.GetUnusedLocalhostPort()\n",
"self._temp_options_filename = options_file.name\n",
"json.dump(dict(self._user_options), options_file)\n",
"options_file.flush()\n",
"args = [utils.PathToPythonInterpreter(), _PathToServerScript(),\n '--port={0}'.format(server_port), '--options_file={0}'.format(\n options_file.name), '--log={0}'.format(self._user_options[\n 'server_log_level']), '--idle_suicide_seconds={0}'.format(\n SERVER_IDLE_SUICIDE_SECONDS)]\n",
"if not self._user_options['server_use_vim_stdout']:\n",
"filename_format = os.path.join(utils.PathToTempDir(), 'server_{port}_{std}.log'\n )\n",
"self._server_popen = utils.SafePopen(args, stdout=PIPE, stderr=PIPE)\n",
"self._server_stdout = filename_format.format(port=server_port, std='stdout')\n",
"BaseRequest.server_location = 'http://localhost:' + str(server_port)\n",
"self._server_stderr = filename_format.format(port=server_port, std='stderr')\n",
"self._NotifyUserIfServerCrashed()\n",
"args.append('--stdout={0}'.format(self._server_stdout))\n",
"args.append('--stderr={0}'.format(self._server_stderr))\n",
"if self._user_options['server_keep_logfiles']:\n",
"args.append('--keep_logfiles')\n"
] | [
0,
0,
7,
7,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Condition",
"Expr'"
] |
[
"def FUNC_7(self):...\n",
"VAR_6 = self.client.get('/api/apps')\n",
"VAR_8 = VAR_6.data['results'][0]['id']\n",
"self.assertTrue(self.client.login(VAR_1='autotest-2', VAR_2='password'))\n",
"VAR_6 = self.client.get('/api/apps/{}/perms'.format(VAR_8), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_6.status_code, 403)\n"
] | [
"def test_list_errors(self):...\n",
"response = self.client.get('/api/apps')\n",
"app_id = response.data['results'][0]['id']\n",
"self.assertTrue(self.client.login(username='autotest-2', password='password'))\n",
"response = self.client.get('/api/apps/{}/perms'.format(app_id),\n content_type='application/json')\n",
"self.assertEqual(response.status_code, 403)\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"def FUNC_32(self, VAR_81):...\n",
"def FUNC_39(VAR_101):...\n",
"VAR_101.shellcmd = VAR_81\n",
"return VAR_101\n"
] | [
"def shellcmd(self, cmd):...\n",
"def decorate(ruleinfo):...\n",
"ruleinfo.shellcmd = cmd\n",
"return ruleinfo\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_1(self):...\n",
"VAR_4 = CLASS_2(id=0)\n",
"VAR_5 = EntityCache(entities=[])\n",
"VAR_5.add(VAR_4)\n",
"self.assert_true(VAR_5.get_by_id(VAR_4.id) is VAR_4)\n",
"self.assert_true(VAR_5.has_id(VAR_4.id))\n",
"self.assert_true(VAR_5.get_by_slug(VAR_4.slug) is VAR_4)\n",
"self.assert_true(VAR_5.has_slug(VAR_4.slug))\n",
"VAR_6 = CLASS_2(id=0)\n",
"VAR_7 = 'FROBNIC'\n",
"VAR_6.text = VAR_7\n",
"VAR_5.replace(VAR_6)\n",
"self.assert_equal(VAR_5.get_by_id(VAR_4.id).text, VAR_7)\n",
"self.assert_equal(VAR_5.get_all(), [VAR_4])\n",
"self.assert_equal(list(VAR_5.retrieve()), [VAR_4])\n",
"VAR_5.remove(VAR_4)\n",
"self.assert_is_none(VAR_5.get_by_id(VAR_4.id))\n",
"self.assert_is_none(VAR_5.get_by_slug(VAR_4.slug))\n"
] | [
"def test_basics(self):...\n",
"ent = MyEntity(id=0)\n",
"cache = EntityCache(entities=[])\n",
"cache.add(ent)\n",
"self.assert_true(cache.get_by_id(ent.id) is ent)\n",
"self.assert_true(cache.has_id(ent.id))\n",
"self.assert_true(cache.get_by_slug(ent.slug) is ent)\n",
"self.assert_true(cache.has_slug(ent.slug))\n",
"ent1 = MyEntity(id=0)\n",
"txt = 'FROBNIC'\n",
"ent1.text = txt\n",
"cache.replace(ent1)\n",
"self.assert_equal(cache.get_by_id(ent.id).text, txt)\n",
"self.assert_equal(cache.get_all(), [ent])\n",
"self.assert_equal(list(cache.retrieve()), [ent])\n",
"cache.remove(ent)\n",
"self.assert_is_none(cache.get_by_id(ent.id))\n",
"self.assert_is_none(cache.get_by_slug(ent.slug))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_12(VAR_24):...\n",
"for user, VAR_20, id1, id2 in VAR_23.findall(VAR_24):\n",
"VAR_21 = id1 + id2\n",
"FUNC_9(VAR_20, VAR_21, user)\n"
] | [
"def rtfu(urls):...\n",
"for user, domain, id1, id2 in r_di.findall(urls):\n",
"id_ = id1 + id2\n",
"remove_target(domain, id_, user)\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"For",
"Assign'",
"Expr'"
] |
[
"def FUNC_0(self, VAR_0='crimemap'):...\n",
"return pymysql.connect(host='localhost', user=dbconfig.db_user, password=\n dbconfig.db_password, db=database)\n"
] | [
"def connect(self, database='crimemap'):...\n",
"return pymysql.connect(host='localhost', user=dbconfig.db_user, password=\n dbconfig.db_password, db=database)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_7(self):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_1 = self.bindings\n",
"VAR_7 = VAR_1['TEST_APP_COMPONENT_NAME']\n",
"VAR_15 = '{app}-{stack}-v000'.format(app=self.TEST_APP, stack=bindings[\n 'TEST_STACK'])\n",
"VAR_8 = VAR_1['TEST_AWS_REGION']\n",
"VAR_9 = [VAR_8 + 'a', VAR_8 + 'b']\n",
"VAR_12 = self.agent.make_json_payload_from_kwargs(job=[{'type':\n 'createServerGroup', 'cloudProvider': 'aws', 'application': self.\n TEST_APP, 'credentials': bindings['AWS_CREDENTIALS'], 'strategy': '',\n 'capacity': {'min': 2, 'max': 2, 'desired': 2},\n 'targetHealthyDeployPercentage': 100, 'loadBalancers': [\n load_balancer_name], 'cooldown': 8, 'healthCheckType': 'EC2',\n 'healthCheckGracePeriod': 40, 'instanceMonitoring': False,\n 'ebsOptimized': False, 'iamRole': bindings['AWS_IAM_ROLE'],\n 'terminationPolicies': ['Default'], 'availabilityZones': {region:\n avail_zones}, 'keyPair': bindings['AWS_CREDENTIALS'] + '-keypair',\n 'suspendedProcesses': [], 'subnetType': 'internal (defaultvpc)',\n 'securityGroups': [bindings['TEST_AWS_SECURITY_GROUP_ID']],\n 'virtualizationType': 'paravirtual', 'stack': bindings['TEST_STACK'],\n 'freeFormDetails': '', 'amiName': bindings['TEST_AWS_AMI'],\n 'instanceType': 'm1.small', 'useSourceCapacity': False, 'account':\n bindings['AWS_CREDENTIALS'], 'user': '[anonymous]'}], description=\n 'Create Server Group in ' + group_name, application=self.TEST_APP)\n",
"VAR_13 = aws.AwsContractBuilder(self.aws_observer)\n",
"VAR_13.new_clause_builder('Auto Server Group Added', retryable_for_secs=30\n ).collect_resources('autoscaling', 'describe-auto-scaling-groups', args\n =['--auto-scaling-group-names', group_name]).contains_path_value(\n 'AutoScalingGroups', {'MaxSize': 2})\n",
"return st.OperationContract(self.new_post_operation(title=\n 'create_server_group', data=payload, path='tasks'), VAR_6=builder.build())\n"
] | [
"def create_server_group(self):...\n",
"\"\"\"docstring\"\"\"\n",
"bindings = self.bindings\n",
"load_balancer_name = bindings['TEST_APP_COMPONENT_NAME']\n",
"group_name = '{app}-{stack}-v000'.format(app=self.TEST_APP, stack=bindings[\n 'TEST_STACK'])\n",
"region = bindings['TEST_AWS_REGION']\n",
"avail_zones = [region + 'a', region + 'b']\n",
"payload = self.agent.make_json_payload_from_kwargs(job=[{'type':\n 'createServerGroup', 'cloudProvider': 'aws', 'application': self.\n TEST_APP, 'credentials': bindings['AWS_CREDENTIALS'], 'strategy': '',\n 'capacity': {'min': 2, 'max': 2, 'desired': 2},\n 'targetHealthyDeployPercentage': 100, 'loadBalancers': [\n load_balancer_name], 'cooldown': 8, 'healthCheckType': 'EC2',\n 'healthCheckGracePeriod': 40, 'instanceMonitoring': False,\n 'ebsOptimized': False, 'iamRole': bindings['AWS_IAM_ROLE'],\n 'terminationPolicies': ['Default'], 'availabilityZones': {region:\n avail_zones}, 'keyPair': bindings['AWS_CREDENTIALS'] + '-keypair',\n 'suspendedProcesses': [], 'subnetType': 'internal (defaultvpc)',\n 'securityGroups': [bindings['TEST_AWS_SECURITY_GROUP_ID']],\n 'virtualizationType': 'paravirtual', 'stack': bindings['TEST_STACK'],\n 'freeFormDetails': '', 'amiName': bindings['TEST_AWS_AMI'],\n 'instanceType': 'm1.small', 'useSourceCapacity': False, 'account':\n bindings['AWS_CREDENTIALS'], 'user': '[anonymous]'}], description=\n 'Create Server Group in ' + group_name, application=self.TEST_APP)\n",
"builder = aws.AwsContractBuilder(self.aws_observer)\n",
"builder.new_clause_builder('Auto Server Group Added', retryable_for_secs=30\n ).collect_resources('autoscaling', 'describe-auto-scaling-groups', args\n =['--auto-scaling-group-names', group_name]).contains_path_value(\n 'AutoScalingGroups', {'MaxSize': 2})\n",
"return st.OperationContract(self.new_post_operation(title=\n 'create_server_group', data=payload, path='tasks'), contract=builder.\n build())\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"from os.path import join\n",
"from datetime import datetime\n",
"from flask import request, redirect, url_for, render_template, flash, g, current_app\n",
"from werkzeug.utils import secure_filename\n",
"from flask_security import login_required, current_user\n",
"from benwaonline.database import db\n",
"from benwaonline.models import Post, Tag, Comment, Preview, Image\n",
"from benwaonline.gallery import gallery\n",
"from benwaonline.gallery.forms import CommentForm, PostForm\n",
"@gallery.before_request...\n",
"g.user = current_user\n",
"@gallery.route('/gallery/')...\n",
"if VAR_0 == 'all':\n",
"VAR_9 = Post.query.all()\n",
"VAR_10 = VAR_0.split(' ')\n",
"VAR_0 = Tag.query.all()\n",
"VAR_9 = []\n",
"return render_template('gallery.html', VAR_9=posts, VAR_0=tags)\n",
"for s in VAR_10:\n",
"VAR_18 = Post.query.filter(Post.tags.any(name=s))\n",
"VAR_9.extend(VAR_18)\n"
] | [
"from os.path import join\n",
"from datetime import datetime\n",
"from flask import request, redirect, url_for, render_template, flash, g, current_app\n",
"from werkzeug.utils import secure_filename\n",
"from flask_security import login_required, current_user\n",
"from benwaonline.database import db\n",
"from benwaonline.models import Post, Tag, Comment, Preview, Image\n",
"from benwaonline.gallery import gallery\n",
"from benwaonline.gallery.forms import CommentForm, PostForm\n",
"@gallery.before_request...\n",
"g.user = current_user\n",
"@gallery.route('/gallery/')...\n",
"if tags == 'all':\n",
"posts = Post.query.all()\n",
"split = tags.split(' ')\n",
"tags = Tag.query.all()\n",
"posts = []\n",
"return render_template('gallery.html', posts=posts, tags=tags)\n",
"for s in split:\n",
"results = Post.query.filter(Post.tags.any(name=s))\n",
"posts.extend(results)\n"
] | [
0,
0,
6,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"For",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'",
"For",
"Assign'",
"Expr'"
] |
[
"@VAR_0.route('/list')...\n",
"if VAR_3 is None:\n",
"VAR_3 = request.args.get('start', None, float)\n",
"if VAR_4 is None:\n",
"VAR_4 = request.args.get('end', None, float)\n",
"if VAR_5 is None:\n",
"VAR_5 = request.args.get('limit', 100, int)\n",
"if VAR_6 is None:\n",
"VAR_6 = request.args.get('format', 'plain', str)\n",
"if VAR_7 is None:\n",
"VAR_6 = request.args.get('download', 'no')\n",
"if VAR_8 is None:\n",
"VAR_8 = request.args.get('degree', None, int)\n",
"if VAR_5 > 1000:\n",
"VAR_5 = 1000\n",
"if VAR_5 < 0:\n",
"VAR_5 = 100\n",
"if VAR_3 is None and VAR_4 is None:\n",
"VAR_4 = 1000\n",
"VAR_5 = int(VAR_5)\n",
"VAR_11 = 'WHERE 1=1 '\n",
"if VAR_4 is not None:\n",
"VAR_4 = str(VAR_4)\n",
"if VAR_3 is None:\n",
"if '.' in VAR_4:\n",
"VAR_11 += ' AND zero <= ' + VAR_4\n",
"if VAR_4 is None:\n",
"VAR_4 = VAR_4 + '999'\n",
"if VAR_8 is not None and VAR_8 != '':\n",
"VAR_3 = float(VAR_3)\n",
"VAR_11 += ' AND zero >= {} AND zero <= {}'.format(VAR_3, VAR_4)\n",
"VAR_11 += ' AND degree = ' + str(VAR_8)\n",
"if VAR_4 is None:\n",
"VAR_11 += ' AND zero >= ' + str(VAR_3)\n",
"VAR_14 = (\n 'SELECT * FROM (SELECT * FROM zeros {} ORDER BY zero ASC LIMIT {}) ORDER BY zero DESC'\n .format(VAR_11, VAR_5))\n",
"VAR_14 = 'SELECT * FROM zeros {} ORDER BY zero DESC LIMIT {}'.format(VAR_11,\n VAR_5)\n",
"VAR_12 = sqlite3.connect(VAR_2 + 'first_zeros.db').cursor()\n",
"VAR_12.execute(VAR_14)\n",
"VAR_13 = flask.Response(' '.join([str(x) for x in row]) + '\\n' for row in\n VAR_12)\n",
"VAR_13.headers['content-type'] = 'text/plain'\n",
"if VAR_7 == 'yes':\n",
"VAR_13.headers['content-disposition'] = 'attachment; filename=zetazeros'\n",
"return VAR_13\n"
] | [
"@FirstZeros.route('/list')...\n",
"if start is None:\n",
"start = request.args.get('start', None, float)\n",
"if end is None:\n",
"end = request.args.get('end', None, float)\n",
"if limit is None:\n",
"limit = request.args.get('limit', 100, int)\n",
"if fmt is None:\n",
"fmt = request.args.get('format', 'plain', str)\n",
"if download is None:\n",
"fmt = request.args.get('download', 'no')\n",
"if degree is None:\n",
"degree = request.args.get('degree', None, int)\n",
"if limit > 1000:\n",
"limit = 1000\n",
"if limit < 0:\n",
"limit = 100\n",
"if start is None and end is None:\n",
"end = 1000\n",
"limit = int(limit)\n",
"where_clause = 'WHERE 1=1 '\n",
"if end is not None:\n",
"end = str(end)\n",
"if start is None:\n",
"if '.' in end:\n",
"where_clause += ' AND zero <= ' + end\n",
"if end is None:\n",
"end = end + '999'\n",
"if degree is not None and degree != '':\n",
"start = float(start)\n",
"where_clause += ' AND zero >= {} AND zero <= {}'.format(start, end)\n",
"where_clause += ' AND degree = ' + str(degree)\n",
"if end is None:\n",
"where_clause += ' AND zero >= ' + str(start)\n",
"query = (\n 'SELECT * FROM (SELECT * FROM zeros {} ORDER BY zero ASC LIMIT {}) ORDER BY zero DESC'\n .format(where_clause, limit))\n",
"query = 'SELECT * FROM zeros {} ORDER BY zero DESC LIMIT {}'.format(\n where_clause, limit)\n",
"c = sqlite3.connect(data_location + 'first_zeros.db').cursor()\n",
"c.execute(query)\n",
"response = flask.Response(' '.join([str(x) for x in row]) + '\\n' for row in c)\n",
"response.headers['content-type'] = 'text/plain'\n",
"if download == 'yes':\n",
"response.headers['content-disposition'] = 'attachment; filename=zetazeros'\n",
"return response\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
4,
0,
4,
4,
0,
4,
0,
0,
4,
4,
0,
4,
0,
0,
0,
4,
0,
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Condition",
"AugAssign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"AugAssign'",
"AugAssign'",
"Condition",
"AugAssign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Return'"
] |
[
"def FUNC_5(self):...\n",
"self._check_duplicate_key(VAR_0)\n"
] | [
"def test_rsa_duplicate_key(self):...\n",
"self._check_duplicate_key(RSA_PUBKEY)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_33(VAR_57, VAR_22):...\n",
"if not len(VAR_57):\n",
"VAR_56.append('/%s' % ('/'.join(VAR_22),))\n",
"if VAR_57[0] == '.':\n",
"FUNC_33(VAR_57[1:], VAR_22)\n",
"if VAR_57[0] == '..':\n",
"FUNC_33(VAR_57[1:], VAR_22[:-1])\n",
"VAR_65 = [x[VAR_1] for x in self.get_path('/'.join(VAR_22))]\n",
"VAR_74 = [x for x in VAR_65 if fnmatch.fnmatchcase(x, VAR_57[0])]\n",
"for match in VAR_74:\n",
"FUNC_33(VAR_57[1:], VAR_22 + [match])\n"
] | [
"def foo(p, cwd):...\n",
"if not len(p):\n",
"found.append('/%s' % ('/'.join(cwd),))\n",
"if p[0] == '.':\n",
"foo(p[1:], cwd)\n",
"if p[0] == '..':\n",
"foo(p[1:], cwd[:-1])\n",
"names = [x[A_NAME] for x in self.get_path('/'.join(cwd))]\n",
"matches = [x for x in names if fnmatch.fnmatchcase(x, p[0])]\n",
"for match in matches:\n",
"foo(p[1:], cwd + [match])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"For",
"Expr'"
] |
[
"def FUNC_13(self):...\n",
"VAR_4 = CachedContent(self.course_instance)\n",
"def FUNC_17(VAR_5):...\n",
"VAR_11 = VAR_5['children']\n",
"if VAR_11:\n",
"return itertools.chain.from_iterable([FUNC_17(child) for child in VAR_11])\n",
"return VAR_5['id'],\n"
] | [
"def __get_exercises(self):...\n",
"content = CachedContent(self.course_instance)\n",
"def get_descendant_ids(node):...\n",
"children = node['children']\n",
"if children:\n",
"return itertools.chain.from_iterable([get_descendant_ids(child) for child in\n children])\n",
"return node['id'],\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"FunctionDef'",
"Assign'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_3(self, VAR_8):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_19 = self._cliq_get_cluster_info(VAR_8)\n",
"VAR_20 = []\n",
"for vip in VAR_19.findall('response/cluster/vip'):\n",
"VAR_20.append(vip.attrib.get('ipAddress'))\n",
"if len(VAR_20) == 1:\n",
"return VAR_20[0]\n",
"VAR_21 = etree.tostring(VAR_19)\n",
"VAR_22 = _(\n 'Unexpected number of virtual ips for cluster %(cluster_name)s. Result=%(_xml)s'\n ) % {'cluster_name': VAR_8, '_xml': VAR_21}\n"
] | [
"def _cliq_get_cluster_vip(self, cluster_name):...\n",
"\"\"\"docstring\"\"\"\n",
"cluster_xml = self._cliq_get_cluster_info(cluster_name)\n",
"vips = []\n",
"for vip in cluster_xml.findall('response/cluster/vip'):\n",
"vips.append(vip.attrib.get('ipAddress'))\n",
"if len(vips) == 1:\n",
"return vips[0]\n",
"_xml = etree.tostring(cluster_xml)\n",
"msg = _(\n 'Unexpected number of virtual ips for cluster %(cluster_name)s. Result=%(_xml)s'\n ) % {'cluster_name': cluster_name, '_xml': _xml}\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"For",
"Expr'",
"Condition",
"Return'",
"Assign'",
"Assign'"
] |
[
"def FUNC_24(self, VAR_25):...\n",
"for VAR_24 in self.databases_to_save:\n",
"VAR_24.database_manager.save_database()\n",
"self.quit_dialog.destroy()\n",
"self.application.quit()\n"
] | [
"def on_quit_button_clicked(self, button):...\n",
"for db in self.databases_to_save:\n",
"db.database_manager.save_database()\n",
"self.quit_dialog.destroy()\n",
"self.application.quit()\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"For",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_0(self):...\n",
"VAR_1, VAR_2 = 'firstuser', 'password'\n",
"VAR_3 = '[email protected]'\n",
"VAR_4 = {'username': VAR_1, 'password': VAR_2, 'email': VAR_3}\n",
"VAR_5 = '/api/auth/register'\n",
"VAR_6 = self.client.post(VAR_5, json.dumps(VAR_4), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_6.status_code, 201)\n",
"self.assertTrue(VAR_6.data['is_superuser'])\n",
"VAR_1, VAR_2 = 'seconduser', 'password'\n",
"VAR_3 = '[email protected]'\n",
"VAR_4 = {'username': VAR_1, 'password': VAR_2, 'email': VAR_3}\n",
"VAR_5 = '/api/auth/register'\n",
"VAR_6 = self.client.post(VAR_5, json.dumps(VAR_4), content_type=\n 'application/json')\n",
"self.assertEqual(VAR_6.status_code, 201)\n",
"self.assertFalse(VAR_6.data['is_superuser'])\n"
] | [
"def test_first_signup(self):...\n",
"username, password = 'firstuser', 'password'\n",
"email = '[email protected]'\n",
"submit = {'username': username, 'password': password, 'email': email}\n",
"url = '/api/auth/register'\n",
"response = self.client.post(url, json.dumps(submit), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 201)\n",
"self.assertTrue(response.data['is_superuser'])\n",
"username, password = 'seconduser', 'password'\n",
"email = '[email protected]'\n",
"submit = {'username': username, 'password': password, 'email': email}\n",
"url = '/api/auth/register'\n",
"response = self.client.post(url, json.dumps(submit), content_type=\n 'application/json')\n",
"self.assertEqual(response.status_code, 201)\n",
"self.assertFalse(response.data['is_superuser'])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def __init__(self, VAR_7=True, VAR_8=False):...\n",
"\"\"\"docstring\"\"\"\n",
"super().__init__(description='ParlAI parser.', allow_abbrev=False,\n conflict_handler='resolve')\n",
"self.register('type', 'bool', FUNC_0)\n",
"self.register('type', 'class', FUNC_1)\n",
"self.parlai_home = VAR_20.path.dirname(VAR_20.path.dirname(VAR_20.path.\n dirname(VAR_20.path.realpath(__file__))))\n",
"VAR_20.environ['PARLAI_HOME'] = self.parlai_home\n",
"self.add_arg = self.add_argument\n",
"self.cli_args = sys.argv\n",
"self.overridable = {}\n",
"if VAR_7:\n",
"self.add_parlai_args()\n",
"if VAR_8:\n",
"self.add_model_args()\n"
] | [
"def __init__(self, add_parlai_args=True, add_model_args=False):...\n",
"\"\"\"docstring\"\"\"\n",
"super().__init__(description='ParlAI parser.', allow_abbrev=False,\n conflict_handler='resolve')\n",
"self.register('type', 'bool', str2bool)\n",
"self.register('type', 'class', str2class)\n",
"self.parlai_home = os.path.dirname(os.path.dirname(os.path.dirname(os.path.\n realpath(__file__))))\n",
"os.environ['PARLAI_HOME'] = self.parlai_home\n",
"self.add_arg = self.add_argument\n",
"self.cli_args = sys.argv\n",
"self.overridable = {}\n",
"if add_parlai_args:\n",
"self.add_parlai_args()\n",
"if add_model_args:\n",
"self.add_model_args()\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Condition",
"Expr'"
] |
[
"def FUNC_22(self, VAR_28):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_58 = VAR_28,\n",
"VAR_36 = ''\n",
"if self.execute('SELECT name FROM history WHERE nzo_id=?', VAR_58):\n",
"return VAR_36\n",
"VAR_36 = self.c.fetchone().get('name')\n"
] | [
"def get_name(self, nzo_id):...\n",
"\"\"\"docstring\"\"\"\n",
"t = nzo_id,\n",
"name = ''\n",
"if self.execute('SELECT name FROM history WHERE nzo_id=?', t):\n",
"return name\n",
"name = self.c.fetchone().get('name')\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Assign'"
] |
[
"def FUNC_13(self, VAR_16):...\n",
"\"\"\"docstring\"\"\"\n",
"self._check_volume(VAR_16)\n",
"VAR_0.warn(_('Volume %s was not found while trying to delete it'), VAR_16[\n 'name'])\n",
"self._eql_execute('volume', 'select', VAR_16['name'], 'offline')\n",
"VAR_0.error(_('Failed to delete volume %s'), VAR_16['name'])\n",
"self._eql_execute('volume', 'delete', VAR_16['name'])\n"
] | [
"def delete_volume(self, volume):...\n",
"\"\"\"docstring\"\"\"\n",
"self._check_volume(volume)\n",
"LOG.warn(_('Volume %s was not found while trying to delete it'), volume['name']\n )\n",
"self._eql_execute('volume', 'select', volume['name'], 'offline')\n",
"LOG.error(_('Failed to delete volume %s'), volume['name'])\n",
"self._eql_execute('volume', 'delete', volume['name'])\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_15 = set()\n",
"for VAR_28, VAR_27 in zip(self.output, self.rule.output):\n",
"if VAR_28 in self.dynamic_output:\n",
"VAR_16 = defaultdict(list)\n",
"for VAR_28, w in self.expand_dynamic(VAR_27, VAR_13=self.wildcards, VAR_14=\n",
"for combination in VAR_15:\n",
"VAR_15.add(tuple(w.items()))\n",
"for name, value in combination:\n",
"return VAR_16\n",
"VAR_16[name].append(value)\n"
] | [
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"combinations = set()\n",
"for f, f_ in zip(self.output, self.rule.output):\n",
"if f in self.dynamic_output:\n",
"wildcards = defaultdict(list)\n",
"for f, w in self.expand_dynamic(f_, restriction=self.wildcards, omit_value=\n",
"for combination in combinations:\n",
"combinations.add(tuple(w.items()))\n",
"for name, value in combination:\n",
"return wildcards\n",
"wildcards[name].append(value)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"For",
"Condition",
"Assign'",
"For",
"For",
"Expr'",
"For",
"Return'",
"Expr'"
] |
[
"def FUNC_19(self, VAR_38):...\n",
"\"\"\"docstring\"\"\"\n",
"return self._parse_conditions(self.OR_CONDITION, VAR_38)\n"
] | [
"def _parse_or(self, data):...\n",
"\"\"\"docstring\"\"\"\n",
"return self._parse_conditions(self.OR_CONDITION, data)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def FUNC_42(self):...\n",
"self.cursor.execute('create table t1(c1 int identity(1, 1), c2 varchar(50))')\n",
"for i in range(3):\n",
"self.cursor.execute('insert into t1(c2) values (?)', 'string%s' % i)\n",
"self.cursor.execute('create view t2 as select * from t1')\n",
"self.cursor.execute('select * from t2')\n",
"VAR_29 = self.cursor.fetchall()\n",
"self.assertTrue(VAR_29 is not None)\n",
"self.assertTrue(VAR_23(VAR_29) == 3)\n"
] | [
"def test_view_select(self):...\n",
"self.cursor.execute('create table t1(c1 int identity(1, 1), c2 varchar(50))')\n",
"for i in range(3):\n",
"self.cursor.execute('insert into t1(c2) values (?)', 'string%s' % i)\n",
"self.cursor.execute('create view t2 as select * from t1')\n",
"self.cursor.execute('select * from t2')\n",
"rows = self.cursor.fetchall()\n",
"self.assertTrue(rows is not None)\n",
"self.assertTrue(len(rows) == 3)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"For",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_18(self):...\n",
"self.run_test_case(self.scenario.delete_load_balancer())\n"
] | [
"def test_z_delete_load_balancer(self):...\n",
"self.run_test_case(self.scenario.delete_load_balancer())\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"@VAR_0.route('/upload', methods=['POST'])...\n",
"VAR_8 = request.files['file']\n",
"VAR_9 = MySQL.get_connection(VAR_3)\n",
"if VAR_8:\n",
"VAR_16 = os.path.splitext(VAR_8.filename)[0] + str(int(time.time())) + '.log'\n",
"VAR_9.close()\n",
"VAR_17 = logging.FileHandler(os.path.join(VAR_1, VAR_16), 'w')\n",
"Config.setup_logging(VAR_17)\n",
"VAR_18 = os.path.join(VAR_2, VAR_8.filename)\n",
"VAR_8.save(VAR_18)\n",
"Importer.run(VAR_18, VAR_9)\n",
"logger.removeHandler(VAR_17)\n",
"VAR_17.close()\n",
"return jsonify({'name': VAR_8.filename, 'log': VAR_16})\n"
] | [
"@app.route('/upload', methods=['POST'])...\n",
"datafile = request.files['file']\n",
"c = MySQL.get_connection(DATABASE)\n",
"if datafile:\n",
"logfile = os.path.splitext(datafile.filename)[0] + str(int(time.time())\n ) + '.log'\n",
"c.close()\n",
"f = logging.FileHandler(os.path.join(LOG_DIR, logfile), 'w')\n",
"Config.setup_logging(f)\n",
"filepath = os.path.join(UPLOADS_DIR, datafile.filename)\n",
"datafile.save(filepath)\n",
"Importer.run(filepath, c)\n",
"logger.removeHandler(f)\n",
"f.close()\n",
"return jsonify({'name': datafile.filename, 'log': logfile})\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Return'"
] |
[
"def __bool__(self):...\n",
"return False\n"
] | [
"def __bool__(self):...\n",
"return False\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_0(VAR_0=None):...\n",
"VAR_1 = FUNC_1()\n",
"VAR_2 = FUNC_2(VAR_0)\n",
"return VAR_1, VAR_2\n"
] | [
"def execute(filters=None):...\n",
"columns = get_columns()\n",
"data = get_data(filters)\n",
"return columns, data\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Return'"
] |
[
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"return self.config.get(self.section, 'cert_chain')\n"
] | [
"@property...\n",
"\"\"\"docstring\"\"\"\n",
"return self.config.get(self.section, 'cert_chain')\n"
] | [
0,
0,
0
] | [
"Condition",
"Docstring",
"Return'"
] |
[
"def FUNC_1(self, VAR_0):...\n",
"VAR_19 = dict(self.query_params).copy()\n",
"for VAR_26, VAR_4 in VAR_19.items():\n",
"if type(VAR_4) == list:\n",
"VAR_19.update(VAR_0)\n",
"VAR_19[VAR_26] = VAR_4[0]\n",
"for VAR_26, VAR_4 in VAR_19.copy().items():\n",
"if VAR_4 is None:\n",
"return '?{}'.format(urlencode(VAR_19))\n"
] | [
"def get_url_with_query_params(self, new_query_dict):...\n",
"query = dict(self.query_params).copy()\n",
"for key, value in query.items():\n",
"if type(value) == list:\n",
"query.update(new_query_dict)\n",
"query[key] = value[0]\n",
"for key, value in query.copy().items():\n",
"if value is None:\n",
"return '?{}'.format(urlencode(query))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"For",
"Condition",
"Expr'",
"Assign'",
"For",
"Condition",
"Return'"
] |
[
"def __init__(self):...\n",
"self.__cache_map = defaultdict(CLASS_0)\n"
] | [
"def __init__(self):...\n",
"self.__cache_map = defaultdict(EntityCache)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Assign'"
] |
[
"def FUNC_0(self):...\n",
"\"\"\"docstring\"\"\"\n",
"\"\"\"string\"\"\"\n",
"VAR_6 = request.args.get('username')\n",
"VAR_9 = request.args.get('password')\n",
"if VAR_6.isalnum():\n",
"VAR_16 = db_interac.authenticate(VAR_6, VAR_9)\n",
"VAR_4['error'] = 'username must be alphanumeric'\n",
"VAR_4 = {}\n",
"VAR_4['userId'] = None\n",
"if not VAR_16[0]:\n",
"VAR_4['firstName'] = None\n",
"VAR_4['error'] = 'user could not be authenticated'\n",
"VAR_4['userId'] = VAR_16[1]\n",
"VAR_4['lastName'] = None\n",
"return VAR_4, 401\n",
"VAR_4['firstName'] = VAR_16[2]\n",
"return VAR_4, 401\n",
"VAR_4['lastName'] = VAR_16[3]\n",
"return VAR_4, 200\n"
] | [
"def get(self):...\n",
"\"\"\"docstring\"\"\"\n",
"\"\"\"\n # Check the request comes from appropriate location.\n if not utils.validate_ip(request.remote_addr)\n return {}, 403\n \"\"\"\n",
"username = request.args.get('username')\n",
"password = request.args.get('password')\n",
"if username.isalnum():\n",
"response = db_interac.authenticate(username, password)\n",
"return_obj['error'] = 'username must be alphanumeric'\n",
"return_obj = {}\n",
"return_obj['userId'] = None\n",
"if not response[0]:\n",
"return_obj['firstName'] = None\n",
"return_obj['error'] = 'user could not be authenticated'\n",
"return_obj['userId'] = response[1]\n",
"return_obj['lastName'] = None\n",
"return return_obj, 401\n",
"return_obj['firstName'] = response[2]\n",
"return return_obj, 401\n",
"return_obj['lastName'] = response[3]\n",
"return return_obj, 200\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'",
"Assign'",
"Return'",
"Assign'",
"Return'"
] |
[
"def FUNC_1(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return bool(self.wildcard_names)\n"
] | [
"def has_wildcards(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return bool(self.wildcard_names)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def FUNC_2(self):...\n",
"return self.best_submission\n"
] | [
"def get_best_submission(self):...\n",
"return self.best_submission\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_6(self):...\n",
"\"\"\"docstring\"\"\"\n",
"self.check_image_exists()\n",
"if not self.security_groups:\n",
"self.security_groups[self.tenant_id] = self.verify(25, self.\n _create_security_group, 1, 'Security group can not be created.',\n 'security group creation', self.compute_client)\n",
"VAR_5 = rand_name('ost1_test-server-smoke-')\n",
"VAR_6 = [self.security_groups[self.tenant_id].name]\n",
"VAR_7 = self.verify(200, self._create_server, 2,\n 'Creating instance using the new security group has failed.',\n 'image creation', self.compute_client, VAR_5, VAR_6)\n",
"self.verify(30, self._delete_server, 3, 'Server can not be deleted.',\n 'server deletion', VAR_7)\n"
] | [
"def test_004_create_servers(self):...\n",
"\"\"\"docstring\"\"\"\n",
"self.check_image_exists()\n",
"if not self.security_groups:\n",
"self.security_groups[self.tenant_id] = self.verify(25, self.\n _create_security_group, 1, 'Security group can not be created.',\n 'security group creation', self.compute_client)\n",
"name = rand_name('ost1_test-server-smoke-')\n",
"security_groups = [self.security_groups[self.tenant_id].name]\n",
"server = self.verify(200, self._create_server, 2,\n 'Creating instance using the new security group has failed.',\n 'image creation', self.compute_client, name, security_groups)\n",
"self.verify(30, self._delete_server, 3, 'Server can not be deleted.',\n 'server deletion', server)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_6(self, VAR_18):...\n",
"if not VAR_18:\n",
"self.error()\n",
"return VAR_18\n"
] | [
"def run(self, item):...\n",
"if not item:\n",
"self.error()\n",
"return item\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Expr'",
"Return'"
] |
[
"@classmethod...\n",
"super(CLASS_0, VAR_0).setUpTestData()\n",
"VAR_0.user = UserFactory(email='[email protected]')\n",
"VAR_0.user.set_password('testing')\n",
"VAR_0.user.save()\n"
] | [
"@classmethod...\n",
"super(TestNavigation, cls).setUpTestData()\n",
"cls.user = UserFactory(email='[email protected]')\n",
"cls.user.set_password('testing')\n",
"cls.user.save()\n"
] | [
0,
0,
0,
0,
0
] | [
"Condition",
"Expr'",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_11(self):...\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name', 'issingle, version()'], limit_start=0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name',\n 'issingle, IF(issingle=1, (select name from tabUser), count(name))'],\n limit_start=0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name', 'issingle, (select count(*) from tabSessions)'],\n limit_start=0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name',\n \"issingle, SELECT LOCATE('', `tabUser`.`user`) AS user;\"], limit_start=\n 0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name',\n 'issingle, IF(issingle=1, (SELECT name from tabUser), count(*))'],\n limit_start=0, limit_page_length=1)\n",
"VAR_3 = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n 'count(name)'], limit_start=0, limit_page_length=1)\n",
"self.assertTrue('count(name)' in VAR_3[0])\n",
"VAR_3 = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n \"locate('', name) as _relevance\"], limit_start=0, limit_page_length=1)\n",
"self.assertTrue('_relevance' in VAR_3[0])\n",
"VAR_3 = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n 'date(creation) as creation'], limit_start=0, limit_page_length=1)\n",
"self.assertTrue('creation' in VAR_3[0])\n",
"VAR_3 = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n 'datediff(modified, creation) as date_diff'], limit_start=0,\n limit_page_length=1)\n",
"self.assertTrue('date_diff' in VAR_3[0])\n"
] | [
"def test_query_fields_sanitizer(self):...\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name', 'issingle, version()'], limit_start=0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name',\n 'issingle, IF(issingle=1, (select name from tabUser), count(name))'],\n limit_start=0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name', 'issingle, (select count(*) from tabSessions)'],\n limit_start=0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name',\n \"issingle, SELECT LOCATE('', `tabUser`.`user`) AS user;\"], limit_start=\n 0, limit_page_length=1)\n",
"self.assertRaises(frappe.DataError, DatabaseQuery('DocType').execute,\n fields=['name',\n 'issingle, IF(issingle=1, (SELECT name from tabUser), count(*))'],\n limit_start=0, limit_page_length=1)\n",
"data = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n 'count(name)'], limit_start=0, limit_page_length=1)\n",
"self.assertTrue('count(name)' in data[0])\n",
"data = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n \"locate('', name) as _relevance\"], limit_start=0, limit_page_length=1)\n",
"self.assertTrue('_relevance' in data[0])\n",
"data = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n 'date(creation) as creation'], limit_start=0, limit_page_length=1)\n",
"self.assertTrue('creation' in data[0])\n",
"data = DatabaseQuery('DocType').execute(fields=['name', 'issingle',\n 'datediff(modified, creation) as date_diff'], limit_start=0,\n limit_page_length=1)\n",
"self.assertTrue('date_diff' in data[0])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"@inlineCallbacks...\n",
""
] | [
"@inlineCallbacks...\n",
""
] | [
0,
0
] | [
"Condition",
"Condition"
] |
[
"@VAR_0.route('/login', methods=['POST'])...\n",
"VAR_19 = CLASS_0.query.get(request.form['email'])\n",
"if VAR_19:\n",
"if request.form['password'] == VAR_19.pwd:\n",
"return render_template('unsuccessful-login.html')\n",
"VAR_19.authenticated = True\n",
"VAR_2.session.add(VAR_19)\n",
"VAR_2.session.commit()\n",
"login_user(VAR_19, remember=True)\n",
"return redirect(VAR_4)\n"
] | [
"@app.route('/login', methods=['POST'])...\n",
"user = User.query.get(request.form['email'])\n",
"if user:\n",
"if request.form['password'] == user.pwd:\n",
"return render_template('unsuccessful-login.html')\n",
"user.authenticated = True\n",
"db.session.add(user)\n",
"db.session.commit()\n",
"login_user(user, remember=True)\n",
"return redirect(url_prefix)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Condition",
"For",
"Return'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Return'"
] |
[
"@decorators.require_cronjob...\n",
"VAR_25 = utils.utcnow() - on_error.ERROR_TIME_TO_LIVE\n",
"VAR_18 = models.Error.query(models.Error.created_ts < VAR_25,\n default_options=ndb.QueryOptions(keys_only=True))\n",
"VAR_26 = len(ndb.delete_multi(VAR_18))\n",
"self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'\n",
"self.response.write(str(VAR_26))\n"
] | [
"@decorators.require_cronjob...\n",
"old_cutoff = utils.utcnow() - on_error.ERROR_TIME_TO_LIVE\n",
"items = models.Error.query(models.Error.created_ts < old_cutoff,\n default_options=ndb.QueryOptions(keys_only=True))\n",
"out = len(ndb.delete_multi(items))\n",
"self.response.headers['Content-Type'] = 'text/plain; charset=utf-8'\n",
"self.response.write(str(out))\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_17(self, VAR_18):...\n",
"\"\"\"docstring\"\"\"\n",
"self._eql_execute('volume', 'select', VAR_18['volume_name'], 'snapshot',\n 'delete', VAR_18['name'])\n",
"VAR_0.error(_('Failed to delete snapshot %(snap)s of volume %(vol)s'), {\n 'snap': VAR_18['name'], 'vol': VAR_18['volume_name']})\n"
] | [
"def delete_snapshot(self, snapshot):...\n",
"\"\"\"docstring\"\"\"\n",
"self._eql_execute('volume', 'select', snapshot['volume_name'], 'snapshot',\n 'delete', snapshot['name'])\n",
"LOG.error(_('Failed to delete snapshot %(snap)s of volume %(vol)s'), {\n 'snap': snapshot['name'], 'vol': snapshot['volume_name']})\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'"
] |
[
"def FUNC_11(self):...\n",
"VAR_3 = 5\n",
"for i in range(VAR_3):\n",
"VAR_11 = urllib.urlencode({url_helper.swarm_constants.COUNT_KEY: i})\n",
"self._mox.ReplayAll()\n",
"url_helper.urllib2.urlopen(mox.IgnoreArg(), VAR_11, timeout=mox.IgnoreArg()\n ).AndRaise(urllib2.URLError('url'))\n",
"self.assertEqual(url_helper.UrlOpen('url', max_tries=attempts), None)\n",
"if i != VAR_3 - 1:\n",
"self._mox.VerifyAll()\n",
"time.sleep(mox.IgnoreArg())\n"
] | [
"def testEnsureCountKeyIncludedInOpen(self):...\n",
"attempts = 5\n",
"for i in range(attempts):\n",
"encoded_data = urllib.urlencode({url_helper.swarm_constants.COUNT_KEY: i})\n",
"self._mox.ReplayAll()\n",
"url_helper.urllib2.urlopen(mox.IgnoreArg(), encoded_data, timeout=mox.\n IgnoreArg()).AndRaise(urllib2.URLError('url'))\n",
"self.assertEqual(url_helper.UrlOpen('url', max_tries=attempts), None)\n",
"if i != attempts - 1:\n",
"self._mox.VerifyAll()\n",
"time.sleep(mox.IgnoreArg())\n"
] | [
0,
0,
0,
0,
0,
5,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"For",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_16(self, VAR_9, VAR_7):...\n",
"VAR_18 = threading.Thread(target=self.__execute_interactive, kwargs={\n 'command': command, 'job_id': job_id})\n",
"VAR_18.daemon = True\n",
"VAR_18.start()\n"
] | [
"def _execute_interactive(self, command, job_id):...\n",
"thread = threading.Thread(target=self.__execute_interactive, kwargs={\n 'command': command, 'job_id': job_id})\n",
"thread.daemon = True\n",
"thread.start()\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"from django import template\n",
"from django.utils import timezone\n",
"from lib.errors import TagUsageError\n",
"from ..cache import CachedNews\n",
"from ..models import News\n",
"VAR_0 = template.Library()\n",
"@VAR_0.inclusion_tag('news/user_news.html', takes_context=True)...\n",
"if not 'instance' in VAR_1:\n",
"if not 'now' in VAR_1:\n",
"VAR_1['now'] = timezone.now()\n",
"if not 'course_news' in VAR_1:\n",
"VAR_1['course_news'] = CachedNews(VAR_1['instance'])\n",
"VAR_7 = VAR_1['course_news']\n",
"if VAR_1['is_course_staff']:\n",
"VAR_9, VAR_7 = VAR_7.for_staff()\n",
"VAR_10 = VAR_1['request'].user\n",
"VAR_8 = 0\n",
"VAR_9, VAR_7 = VAR_7.for_user(not VAR_10.is_authenticated() or VAR_10.\n userprofile.is_external)\n",
"for VAR_11 in VAR_7:\n",
"VAR_8 += 1\n",
"return {'is_course_staff': VAR_1['is_course_staff'], 'now': VAR_1['now'],\n 'alerts': VAR_9, 'news': VAR_7, 'more': VAR_3}\n",
"VAR_11['collapsed'] = VAR_8 > VAR_2\n",
"if VAR_3 > 0 and VAR_8 == VAR_3:\n",
"VAR_11['begin_more'] = True\n"
] | [
"from django import template\n",
"from django.utils import timezone\n",
"from lib.errors import TagUsageError\n",
"from ..cache import CachedNews\n",
"from ..models import News\n",
"register = template.Library()\n",
"@register.inclusion_tag('news/user_news.html', takes_context=True)...\n",
"if not 'instance' in context:\n",
"if not 'now' in context:\n",
"context['now'] = timezone.now()\n",
"if not 'course_news' in context:\n",
"context['course_news'] = CachedNews(context['instance'])\n",
"news = context['course_news']\n",
"if context['is_course_staff']:\n",
"alerts, news = news.for_staff()\n",
"user = context['request'].user\n",
"i = 0\n",
"alerts, news = news.for_user(not user.is_authenticated() or user.\n userprofile.is_external)\n",
"for item in news:\n",
"i += 1\n",
"return {'is_course_staff': context['is_course_staff'], 'now': context['now'\n ], 'alerts': alerts, 'news': news, 'more': more}\n",
"item['collapsed'] = i > num\n",
"if more > 0 and i == more:\n",
"item['begin_more'] = True\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
4,
0,
0,
0,
0,
0,
0
] | [
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"Assign'",
"Condition",
"Condition",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"AugAssign'",
"Return'",
"Assign'",
"Condition",
"Assign'"
] |
[
"def FUNC_4(self):...\n",
"assert self.initialised, 'Initialise the map from a file first!'\n",
"for VAR_23 in range(self.mapHeight):\n",
"for VAR_22 in range(self.mapWidth):\n",
"if self.stateMap[VAR_22][VAR_23].isTraversable():\n",
"self.stateMap[VAR_22][VAR_23].setTurningNeighbours(self.nearestNodes(VAR_22,\n VAR_23))\n"
] | [
"def genConnections(self):...\n",
"assert self.initialised, 'Initialise the map from a file first!'\n",
"for row in range(self.mapHeight):\n",
"for col in range(self.mapWidth):\n",
"if self.stateMap[col][row].isTraversable():\n",
"self.stateMap[col][row].setTurningNeighbours(self.nearestNodes(col, row))\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assert'",
"For",
"For",
"Condition",
"Expr'"
] |
[
"def FUNC_3(VAR_5, VAR_6):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_15 = {}\n",
"VAR_15['new_status'] = 'active' if VAR_6 == 'unfreeze' else 'inactive'\n",
"VAR_16 = 'inactive' if VAR_6 == 'unfreeze' else 'active'\n",
"VAR_15['fields'] = pickle.dumps({'scope': VAR_5.key(), 'status': VAR_16})\n",
"for pattern in VAR_0:\n",
"responses.startTask(FUNC_6(pattern), VAR_24=new_context)\n",
"VAR_15['fields'] = pickle.dumps({'program': VAR_5.key(), 'status': VAR_16})\n",
"for pattern in VAR_1:\n",
"responses.startTask(FUNC_6(pattern), VAR_24=new_context)\n",
"VAR_15 = {}\n",
"VAR_16 = 'inactive' if VAR_6 == 'unfreeze' else ['active', 'new']\n",
"VAR_15['fields'] = pickle.dumps({'scope': VAR_5.key(), 'status': VAR_16})\n",
"responses.startTask(FUNC_6(VAR_2[0]), VAR_24=new_context)\n",
"return\n"
] | [
"def _processProgramFreezing(program_entity, mode):...\n",
"\"\"\"docstring\"\"\"\n",
"new_context = {}\n",
"new_context['new_status'] = 'active' if mode == 'unfreeze' else 'inactive'\n",
"old_status = 'inactive' if mode == 'unfreeze' else 'active'\n",
"new_context['fields'] = pickle.dumps({'scope': program_entity.key(),\n 'status': old_status})\n",
"for pattern in ROLE_PER_SCOPE_MODELS_URL_PATTERNS:\n",
"responses.startTask(_constructRequestURL(pattern), context=new_context)\n",
"new_context['fields'] = pickle.dumps({'program': program_entity.key(),\n 'status': old_status})\n",
"for pattern in ROLE_PER_PROGRAM_MODELS_URL_PATTERNS:\n",
"responses.startTask(_constructRequestURL(pattern), context=new_context)\n",
"new_context = {}\n",
"old_status = 'inactive' if mode == 'unfreeze' else ['active', 'new']\n",
"new_context['fields'] = pickle.dumps({'scope': program_entity.key(),\n 'status': old_status})\n",
"responses.startTask(_constructRequestURL(ORG_MODEL_URL_PATTERNS[0]),\n context=new_context)\n",
"return\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Expr'",
"Assign'",
"For",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"def FUNC_10(self, VAR_18):...\n",
"VAR_30 = VAR_18.uuid\n",
"VAR_41 = VAR_18.file_name\n",
"VAR_42 = VAR_18.owner\n",
"VAR_43 = VAR_18.upload_time\n",
"VAR_44 = list()\n",
"VAR_45 = list()\n",
"for VAR_65 in VAR_18.sub_items:\n",
"if VAR_65.is_dir:\n",
"VAR_46 = \"'{\" + ', '.join(i for i in VAR_44) + \"}'\"\n",
"VAR_44.append('\"%s\"' % VAR_65.uuid)\n",
"VAR_76 = '{%s, %s, %s, %s, %s}' % ('\"%s\"' % VAR_65.uuid, '\"%s\"' % VAR_65.\n file_name, '\"%s\"' % VAR_65.owner, '\"%f\"' % VAR_65.upload_time, '\"%s\"' %\n VAR_65.f_uuid)\n",
"VAR_47 = \"'{\" + ', '.join(i for i in VAR_45) + \"}'\"\n",
"VAR_45.append(VAR_76)\n",
"return VAR_30, VAR_41, VAR_42, VAR_43, VAR_46, VAR_47\n"
] | [
"def _sqlify_fsnode(self, item):...\n",
"n_uuid = item.uuid\n",
"n_file_name = item.file_name\n",
"n_owner = item.owner\n",
"n_upload_time = item.upload_time\n",
"n_sub_folders = list()\n",
"n_sub_files = list()\n",
"for i_sub in item.sub_items:\n",
"if i_sub.is_dir:\n",
"n_sub_folders_str = \"'{\" + ', '.join(i for i in n_sub_folders) + \"}'\"\n",
"n_sub_folders.append('\"%s\"' % i_sub.uuid)\n",
"s_attr = '{%s, %s, %s, %s, %s}' % ('\"%s\"' % i_sub.uuid, '\"%s\"' % i_sub.\n file_name, '\"%s\"' % i_sub.owner, '\"%f\"' % i_sub.upload_time, '\"%s\"' %\n i_sub.f_uuid)\n",
"n_sub_files_str = \"'{\" + ', '.join(i for i in n_sub_files) + \"}'\"\n",
"n_sub_files.append(s_attr)\n",
"return n_uuid, n_file_name, n_owner, n_upload_time, n_sub_folders_str, n_sub_files_str\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Condition",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"def FUNC_21(self):...\n",
"@eqlx.with_timeout...\n",
"return 'no timeout'\n"
] | [
"def test_with_timeout(self):...\n",
"@eqlx.with_timeout...\n",
"return 'no timeout'\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'"
] |
[
"def FUNC_0(self, VAR_5):...\n",
"VAR_14 = 'string'.format(VAR_5)\n",
"self.cur.execute(VAR_14)\n",
"return self.cur.fetchall()\n"
] | [
"def get_roster(self, server_id):...\n",
"sql = (\n \"\"\"SELECT username, role\n FROM roles\n WHERE roles.server_id = {0};\n \"\"\"\n .format(server_id))\n",
"self.cur.execute(sql)\n",
"return self.cur.fetchall()\n"
] | [
0,
4,
4,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Return'"
] |
[
"@property...\n",
"return hasattr(self, 'extractedtext')\n"
] | [
"@property...\n",
"return hasattr(self, 'extractedtext')\n"
] | [
0,
0
] | [
"Condition",
"Return'"
] |
[
"def FUNC_22(self, VAR_21, VAR_40):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_57 = self.getfile(VAR_21)\n",
"if VAR_57 == False:\n",
"VAR_57[VAR_6] = FUNC_30.S_IFMT(VAR_57[VAR_6]) | VAR_40\n"
] | [
"def chmod(self, path, perm):...\n",
"\"\"\"docstring\"\"\"\n",
"p = self.getfile(path)\n",
"if p == False:\n",
"p[A_MODE] = stat.S_IFMT(p[A_MODE]) | perm\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'"
] |
[
"def FUNC_1(VAR_1=None):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_4 = 'df -i'\n",
"if VAR_1 is not None:\n",
"VAR_4 = VAR_4 + ' -' + VAR_1\n",
"VAR_2 = {}\n",
"VAR_3 = __salt__['cmd.run'](VAR_4).splitlines()\n",
"for line in VAR_3:\n",
"if line.startswith('Filesystem'):\n",
"return VAR_2\n",
"VAR_5 = line.split()\n",
"if not VAR_5:\n",
"if __grains__['kernel'] == 'OpenBSD':\n",
"VAR_0.warn('Problem parsing inode usage information')\n",
"VAR_2[VAR_5[8]] = {'inodes': int(VAR_5[5]) + int(VAR_5[6]), 'used': VAR_5[5\n ], 'free': VAR_5[6], 'use': VAR_5[7], 'filesystem': VAR_5[0]}\n",
"VAR_2[VAR_5[5]] = {'inodes': VAR_5[1], 'used': VAR_5[2], 'free': VAR_5[3],\n 'use': VAR_5[4], 'filesystem': VAR_5[0]}\n",
"VAR_2 = {}\n"
] | [
"def inodeusage(args=None):...\n",
"\"\"\"docstring\"\"\"\n",
"cmd = 'df -i'\n",
"if args is not None:\n",
"cmd = cmd + ' -' + args\n",
"ret = {}\n",
"out = __salt__['cmd.run'](cmd).splitlines()\n",
"for line in out:\n",
"if line.startswith('Filesystem'):\n",
"return ret\n",
"comps = line.split()\n",
"if not comps:\n",
"if __grains__['kernel'] == 'OpenBSD':\n",
"log.warn('Problem parsing inode usage information')\n",
"ret[comps[8]] = {'inodes': int(comps[5]) + int(comps[6]), 'used': comps[5],\n 'free': comps[6], 'use': comps[7], 'filesystem': comps[0]}\n",
"ret[comps[5]] = {'inodes': comps[1], 'used': comps[2], 'free': comps[3],\n 'use': comps[4], 'filesystem': comps[0]}\n",
"ret = {}\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"For",
"Condition",
"Return'",
"Assign'",
"Condition",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"def FUNC_13(self, VAR_22):...\n",
"\"\"\"docstring\"\"\"\n",
"logging.warning(\"\"\"Authorization error.\n%s\nPeer: %s\nIP: %s\"\"\", VAR_22, api.\n get_peer_identity().to_bytes(), self.request.remote_addr)\n",
"self.abort(403, detail=str(error))\n"
] | [
"def authorization_error(self, error):...\n",
"\"\"\"docstring\"\"\"\n",
"logging.warning(\"\"\"Authorization error.\n%s\nPeer: %s\nIP: %s\"\"\", error, api.\n get_peer_identity().to_bytes(), self.request.remote_addr)\n",
"self.abort(403, detail=str(error))\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'"
] |
[
"def FUNC_0(VAR_0=None):...\n",
"VAR_1 = FUNC_1()\n",
"VAR_2 = FUNC_2(VAR_0)\n",
"return VAR_1, VAR_2\n"
] | [
"def execute(filters=None):...\n",
"columns = get_columns()\n",
"data = get_data(filters)\n",
"return columns, data\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_0(VAR_1):...\n",
"VAR_6 = FUNC_3(VAR_1)\n",
"VAR_7 = VAR_6.cursor(MySQLdb.cursors.DictCursor)\n",
"VAR_8 = (\n \"SELECT * FROM questions WHERE status='not-started' OR status='in-progress' ORDER BY ts DESC;\"\n )\n",
"VAR_7.execute(VAR_8)\n",
"VAR_9 = []\n",
"while True:\n",
"VAR_10 = VAR_7.fetchone()\n",
"if VAR_10 == None:\n",
"VAR_9.append(\n \"<input type='submit' name=questionSubmit value='Answer Selected Question'>\"\n )\n",
"VAR_9.append('string'.format(VAR_2=row['id'], question=row['question'],\n status=row['status'], ts=row['ts']))\n",
"return '\\n'.join(VAR_9)\n",
"if VAR_10['status'] == 'in-progress':\n",
"VAR_9.append('<p>In-Progress Answer: {curr_answer}'.format(curr_answer=row[\n 'answer']))\n",
"VAR_9.append('</div>')\n"
] | [
"def makeQuestionSelect(database):...\n",
"conn = dbConnect(database)\n",
"curs = conn.cursor(MySQLdb.cursors.DictCursor)\n",
"statement = (\n \"SELECT * FROM questions WHERE status='not-started' OR status='in-progress' ORDER BY ts DESC;\"\n )\n",
"curs.execute(statement)\n",
"lines = []\n",
"while True:\n",
"row = curs.fetchone()\n",
"if row == None:\n",
"lines.append(\n \"<input type='submit' name=questionSubmit value='Answer Selected Question'>\"\n )\n",
"lines.append(\n \"\"\"<div style='border:2px solid black;'><input type='radio' name='q_selection' value={id}> Question: {question}\n<p>Status: {status}\n<p>Time submitted: {ts}\"\"\"\n .format(id=row['id'], question=row['question'], status=row['status'],\n ts=row['ts']))\n",
"return '\\n'.join(lines)\n",
"if row['status'] == 'in-progress':\n",
"lines.append('<p>In-Progress Answer: {curr_answer}'.format(curr_answer=row[\n 'answer']))\n",
"lines.append('</div>')\n"
] | [
0,
0,
0,
0,
4,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Expr'",
"Expr'",
"Return'",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_7(self):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_4 = self.parse_body()\n",
"VAR_9 = VAR_4.get('version', None)\n",
"VAR_24 = VAR_4.get('dimensions', {})\n",
"VAR_25 = VAR_4.get('state', {})\n",
"VAR_14 = None\n",
"if VAR_24.get('id'):\n",
"VAR_52 = VAR_24['id']\n",
"if bool(VAR_24.get('quarantined')) or bool(VAR_25.get('quarantined')):\n",
"if isinstance(VAR_52, list) and len(VAR_52) == 1 and isinstance(VAR_52[0],\n",
"return VAR_4, VAR_14, VAR_9, VAR_25, VAR_24, 'Bot self-quarantined'\n",
"VAR_26 = None\n",
"VAR_14 = VAR_24['id'][0]\n",
"for _ in [0]:\n",
"VAR_26 = FUNC_1(self.EXPECTED_KEYS, VAR_4, 'keys')\n",
"if VAR_26:\n",
"if VAR_26:\n",
"VAR_50 = \"\"\"Quarantined Bot\nhttps://%s/restricted/bot/%s\n%s\"\"\" % (app_identity\n .get_default_version_hostname(), VAR_14, VAR_26)\n",
"VAR_27 = bot_management.get_settings_key(VAR_14).get()\n",
"VAR_26 = FUNC_4(self.REQUIRED_STATE_KEYS, VAR_25, 'state')\n",
"ereporter2.log_request(self.request, VAR_5='bot', VAR_8=line)\n",
"if bool(VAR_27 and VAR_27.quarantined):\n",
"if VAR_26:\n",
"return VAR_4, VAR_14, VAR_9, VAR_25, VAR_24, VAR_26\n",
"return VAR_4, VAR_14, VAR_9, VAR_25, VAR_24, 'Quarantined by admin'\n",
"return VAR_4, VAR_14, VAR_9, VAR_25, VAR_24, None\n",
"if not VAR_14:\n",
"VAR_26 = 'Missing bot id'\n",
"if not all(isinstance(key, unicode) and isinstance(values, list) and all(\n",
"VAR_26 = \"\"\"Invalid dimensions type:\n%s\"\"\" % json.dumps(VAR_24, sort_keys=\n True, indent=2, separators=(',', ': '))\n",
"VAR_53 = task_to_run.dimensions_powerset_count(VAR_24)\n",
"if VAR_53 > task_to_run.MAX_DIMENSIONS:\n",
"VAR_26 = 'Dimensions product %d is too high' % VAR_53\n",
"if not isinstance(VAR_25.get('lease_expiration_ts'), (None.__class__, int)):\n",
"VAR_26 = 'lease_expiration_ts (%r) must be int or None' % VAR_25[\n 'lease_expiration_ts']\n"
] | [
"def _process(self):...\n",
"\"\"\"docstring\"\"\"\n",
"request = self.parse_body()\n",
"version = request.get('version', None)\n",
"dimensions = request.get('dimensions', {})\n",
"state = request.get('state', {})\n",
"bot_id = None\n",
"if dimensions.get('id'):\n",
"dimension_id = dimensions['id']\n",
"if bool(dimensions.get('quarantined')) or bool(state.get('quarantined')):\n",
"if isinstance(dimension_id, list) and len(dimension_id) == 1 and isinstance(\n",
"return request, bot_id, version, state, dimensions, 'Bot self-quarantined'\n",
"quarantined_msg = None\n",
"bot_id = dimensions['id'][0]\n",
"for _ in [0]:\n",
"quarantined_msg = has_unexpected_keys(self.EXPECTED_KEYS, request, 'keys')\n",
"if quarantined_msg:\n",
"if quarantined_msg:\n",
"line = \"\"\"Quarantined Bot\nhttps://%s/restricted/bot/%s\n%s\"\"\" % (app_identity\n .get_default_version_hostname(), bot_id, quarantined_msg)\n",
"bot_settings = bot_management.get_settings_key(bot_id).get()\n",
"quarantined_msg = has_missing_keys(self.REQUIRED_STATE_KEYS, state, 'state')\n",
"ereporter2.log_request(self.request, source='bot', message=line)\n",
"if bool(bot_settings and bot_settings.quarantined):\n",
"if quarantined_msg:\n",
"return request, bot_id, version, state, dimensions, quarantined_msg\n",
"return request, bot_id, version, state, dimensions, 'Quarantined by admin'\n",
"return request, bot_id, version, state, dimensions, None\n",
"if not bot_id:\n",
"quarantined_msg = 'Missing bot id'\n",
"if not all(isinstance(key, unicode) and isinstance(values, list) and all(\n",
"quarantined_msg = \"\"\"Invalid dimensions type:\n%s\"\"\" % json.dumps(dimensions,\n sort_keys=True, indent=2, separators=(',', ': '))\n",
"dimensions_count = task_to_run.dimensions_powerset_count(dimensions)\n",
"if dimensions_count > task_to_run.MAX_DIMENSIONS:\n",
"quarantined_msg = 'Dimensions product %d is too high' % dimensions_count\n",
"if not isinstance(state.get('lease_expiration_ts'), (None.__class__, int)):\n",
"quarantined_msg = 'lease_expiration_ts (%r) must be int or None' % state[\n 'lease_expiration_ts']\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Condition",
"Return'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Condition",
"Condition",
"Return'",
"Return'",
"Return'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'"
] |
[
"def FUNC_12(self, VAR_21):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_24 = self.getfile(VAR_21)\n",
"return False\n",
"return VAR_24[VAR_2] == VAR_11\n"
] | [
"def islink(self, path):...\n",
"\"\"\"docstring\"\"\"\n",
"f = self.getfile(path)\n",
"return False\n",
"return f[A_TYPE] == T_LINK\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Return'",
"Return'"
] |
[
"def FUNC_0(self, VAR_1):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_11 = json.dumps(VAR_1)\n",
"VAR_11 = json.dumps(fix_unicode_dict(VAR_1))\n",
"if len(self.events_requests) == 0:\n",
"return\n",
"[VAR_9.write(VAR_11 + '\\n') for VAR_9 in self.events_requests]\n"
] | [
"def write_data(self, message):...\n",
"\"\"\"docstring\"\"\"\n",
"message_str = json.dumps(message)\n",
"message_str = json.dumps(fix_unicode_dict(message))\n",
"if len(self.events_requests) == 0:\n",
"return\n",
"[request.write(message_str + '\\n') for request in self.events_requests]\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Condition",
"Return'",
"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_29(self):...\n",
"if VAR_54.flags.in_import:\n",
"return\n",
"for VAR_25 in self.meta.get_select_fields():\n",
"if VAR_25.fieldname == 'naming_series' or not (self.get(VAR_25.fieldname) and\n",
"VAR_56 = (VAR_25.options or '').split('\\n')\n",
"if not filter(None, VAR_56):\n",
"self.set(VAR_25.fieldname, cstr(self.get(VAR_25.fieldname)).strip())\n",
"VAR_9 = self.get(VAR_25.fieldname)\n",
"if VAR_9 not in VAR_56 and not (VAR_54.flags.in_test and VAR_9.startswith(\n",
"VAR_67 = _('Row #{0}:').format(self.idx) if self.get('parentfield') else ''\n",
"VAR_37 = _(self.meta.get_label(VAR_25.fieldname))\n",
"VAR_68 = '\", \"'.join(_(each) for each in VAR_56)\n",
"VAR_54.throw(_('{0} {1} cannot be \"{2}\". It should be one of \"{3}\"').format\n (VAR_67, VAR_37, VAR_9, VAR_68))\n"
] | [
"def _validate_selects(self):...\n",
"if frappe.flags.in_import:\n",
"return\n",
"for df in self.meta.get_select_fields():\n",
"if df.fieldname == 'naming_series' or not (self.get(df.fieldname) and df.\n",
"options = (df.options or '').split('\\n')\n",
"if not filter(None, options):\n",
"self.set(df.fieldname, cstr(self.get(df.fieldname)).strip())\n",
"value = self.get(df.fieldname)\n",
"if value not in options and not (frappe.flags.in_test and value.startswith(\n",
"prefix = _('Row #{0}:').format(self.idx) if self.get('parentfield') else ''\n",
"label = _(self.meta.get_label(df.fieldname))\n",
"comma_options = '\", \"'.join(_(each) for each in options)\n",
"frappe.throw(_('{0} {1} cannot be \"{2}\". It should be one of \"{3}\"').format\n (prefix, label, value, comma_options))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Return'",
"For",
"Condition",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_9(self, VAR_13, VAR_14='result'):...\n",
"self.cursor.execute('SELECT COUNT(*) FROM log_' + VAR_13 + ' WHERE ' +\n VAR_14 + '_id=?', [getattr(self, VAR_14)['id']])\n",
"return self.cursor.fetchone()['COUNT(*)']\n"
] | [
"def get_count(self, item, item_from='result'):...\n",
"self.cursor.execute('SELECT COUNT(*) FROM log_' + item + ' WHERE ' +\n item_from + '_id=?', [getattr(self, item_from)['id']])\n",
"return self.cursor.fetchone()['COUNT(*)']\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Return'"
] |
[
"def FUNC_5(*VAR_12):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_22 = np.asarray(VAR_12)\n",
"return VAR_22 / np.linalg.norm(VAR_22)\n"
] | [
"def ket(*args):...\n",
"\"\"\"docstring\"\"\"\n",
"state = np.asarray(args)\n",
"return state / np.linalg.norm(state)\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Return'"
] |
[
"@utils.synchronized('3par', external=True)...\n",
"self.common.client_login()\n",
"self.common.delete_snapshot(VAR_9)\n",
"self.common.client_logout()\n"
] | [
"@utils.synchronized('3par', external=True)...\n",
"self.common.client_login()\n",
"self.common.delete_snapshot(snapshot)\n",
"self.common.client_logout()\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_11(VAR_1, VAR_2):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_10 = False\n",
"VAR_11 = db.connection.cursor(db.pymysql.cursors.DictCursor)\n",
"VAR_11.execute('SELECT type FROM achievement_definitions WHERE id = %s', VAR_1)\n",
"VAR_9 = VAR_11.fetchone()\n",
"if VAR_9['type'] != 'STANDARD':\n",
"VAR_11.execute('string', (VAR_1, VAR_2))\n",
"VAR_14 = VAR_11.fetchone()\n",
"VAR_15 = 'UNLOCKED'\n",
"VAR_10 = not VAR_14 or VAR_14['state'] != 'UNLOCKED'\n",
"VAR_11.execute('string', {'player_id': VAR_2, 'achievement_id': VAR_1,\n 'state': VAR_15})\n",
"return dict(VAR_10=newly_unlocked)\n"
] | [
"def unlock_achievement(achievement_id, player_id):...\n",
"\"\"\"docstring\"\"\"\n",
"newly_unlocked = False\n",
"cursor = db.connection.cursor(db.pymysql.cursors.DictCursor)\n",
"cursor.execute('SELECT type FROM achievement_definitions WHERE id = %s',\n achievement_id)\n",
"achievement = cursor.fetchone()\n",
"if achievement['type'] != 'STANDARD':\n",
"cursor.execute(\n \"\"\"SELECT\n state\n FROM player_achievements\n WHERE achievement_id = %s AND player_id = %s\"\"\"\n , (achievement_id, player_id))\n",
"player_achievement = cursor.fetchone()\n",
"new_state = 'UNLOCKED'\n",
"newly_unlocked = not player_achievement or player_achievement['state'\n ] != 'UNLOCKED'\n",
"cursor.execute(\n \"\"\"INSERT INTO player_achievements (player_id, achievement_id, state)\n VALUES\n (%(player_id)s, %(achievement_id)s, %(state)s)\n ON DUPLICATE KEY UPDATE\n state = VALUES(state)\"\"\"\n , {'player_id': player_id, 'achievement_id': achievement_id, 'state':\n new_state})\n",
"return dict(newly_unlocked=newly_unlocked)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"def FUNC_8(self, VAR_43):...\n",
"VAR_82 = self.divex.match(VAR_43)\n",
"if VAR_82 is None:\n",
"VAR_83 = VAR_82.group(1)\n",
"VAR_84 = VAR_82.group(2)\n",
"VAR_85 = 'mod'\n",
"VAR_86 = int(VAR_82.group(3))\n",
"VAR_41 = VAR_82.group(4)\n",
"VAR_87 = self._parse_poly(VAR_83, VAR_41)\n",
"VAR_88 = self._parse_poly(VAR_84, VAR_41)\n",
"VAR_89 = polylib.IntField(VAR_86)\n",
"VAR_90 = polylib.FieldPoly(VAR_89, VAR_87)\n",
"VAR_91 = polylib.FieldPoly(VAR_89, VAR_88)\n",
"return VAR_90, VAR_85, VAR_91\n"
] | [
"def _parse_instruction(self, s):...\n",
"match = self.divex.match(s)\n",
"if match is None:\n",
"poly1 = match.group(1)\n",
"poly2 = match.group(2)\n",
"instruction = 'mod'\n",
"p = int(match.group(3))\n",
"var = match.group(4)\n",
"cs1 = self._parse_poly(poly1, var)\n",
"cs2 = self._parse_poly(poly2, var)\n",
"field = polylib.IntField(p)\n",
"p1 = polylib.FieldPoly(field, cs1)\n",
"p2 = polylib.FieldPoly(field, cs2)\n",
"return p1, instruction, p2\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def __str__(self):...\n",
"return self.name\n"
] | [
"def __str__(self):...\n",
"return self.name\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_17(self, VAR_50, **VAR_18):...\n",
"VAR_57 = getattr(self._record, VAR_50.lower())\n",
"VAR_57.assert_called_once_with(**kwargs)\n"
] | [
"def assert_called_once(self, verb, **kwargs):...\n",
"mock_call = getattr(self._record, verb.lower())\n",
"mock_call.assert_called_once_with(**kwargs)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'"
] |
[
"def FUNC_39(VAR_62):...\n",
"return json.loads(VAR_62) if VAR_21 else VAR_62\n"
] | [
"def get_str(_str):...\n",
"return json.loads(_str) if as_json else _str\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_1(VAR_1, VAR_2=False, VAR_3=False):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_7 = {}\n",
"if VAR_2 and VAR_3:\n",
"VAR_0.error(e)\n",
"return VAR_7\n",
"for VAR_11 in FUNC_3(VAR_1):\n",
"if not VAR_2:\n",
"VAR_7[VAR_11.username] = VAR_11.signed\n",
"if VAR_3:\n",
"for VAR_11 in FUNC_4(VAR_1):\n",
"for VAR_11 in FUNC_5(VAR_1):\n",
"VAR_7[VAR_11.username] = VAR_11.signed\n",
"VAR_7[VAR_11.username] = bool(VAR_11.signed)\n"
] | [
"def get_signed_packets(member, intro=False, onfloor=False):...\n",
"\"\"\"docstring\"\"\"\n",
"signed_packets = {}\n",
"if intro and onfloor:\n",
"LOGGER.error(e)\n",
"return signed_packets\n",
"for signature in query_signed_intromember(member):\n",
"if not intro:\n",
"signed_packets[signature.username] = signature.signed\n",
"if onfloor:\n",
"for signature in query_signed_upperclassman(member):\n",
"for signature in query_signed_alumni(member):\n",
"signed_packets[signature.username] = signature.signed\n",
"signed_packets[signature.username] = bool(signature.signed)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Expr'",
"Return'",
"For",
"Condition",
"Assign'",
"Condition",
"For",
"For",
"Assign'",
"Assign'"
] |
[
"def FUNC_22(self, VAR_21=None):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_22 = {}\n",
"self.clean_fields(VAR_21)\n",
"VAR_22 = e.update_error_dict(VAR_22)\n",
"self.clean()\n",
"VAR_22 = e.update_error_dict(VAR_22)\n",
"if VAR_22:\n"
] | [
"def full_clean(self, exclude=None):...\n",
"\"\"\"docstring\"\"\"\n",
"errors = {}\n",
"self.clean_fields(exclude)\n",
"errors = e.update_error_dict(errors)\n",
"self.clean()\n",
"errors = e.update_error_dict(errors)\n",
"if errors:\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Condition"
] |
[
"def FUNC_61():...\n",
"self.cursor.execute('create table t1 (word varchar (100))')\n",
"VAR_39 = set(['a'])\n",
"self.cursor.executemany('insert into t1 (word) values (?)', [VAR_39])\n"
] | [
"def f():...\n",
"self.cursor.execute('create table t1 (word varchar (100))')\n",
"words = set(['a'])\n",
"self.cursor.executemany('insert into t1 (word) values (?)', [words])\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"@staticmethod...\n",
"if VAR_5 == 'north':\n",
"return 'east'\n",
"if VAR_5 == 'east':\n",
"return 'north'\n",
"if VAR_5 == 'south':\n",
"return 'west'\n",
"if VAR_5 == 'west':\n",
"return 'south'\n"
] | [
"@staticmethod...\n",
"if direction == 'north':\n",
"return 'east'\n",
"if direction == 'east':\n",
"return 'north'\n",
"if direction == 'south':\n",
"return 'west'\n",
"if direction == 'west':\n",
"return 'south'\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Condition",
"Return'",
"Condition",
"Return'",
"Condition",
"Return'"
] |
[
"def FUNC_2(self, VAR_6, VAR_7):...\n",
"\"\"\"docstring\"\"\"\n",
"self._logger.error('Error with job %d: %s', VAR_6, VAR_7)\n",
"self.put('worker/%s' % VAR_6, data={'log': message, 'returncode': 1, 'host':\n socket.gethostbyaddr(socket.getfqdn())})\n",
"self._logger.exception('Error trying to PUT back abort message')\n"
] | [
"def _abort(self, job_id, message):...\n",
"\"\"\"docstring\"\"\"\n",
"self._logger.error('Error with job %d: %s', job_id, message)\n",
"self.put('worker/%s' % job_id, data={'log': message, 'returncode': 1,\n 'host': socket.gethostbyaddr(socket.getfqdn())})\n",
"self._logger.exception('Error trying to PUT back abort message')\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Expr'"
] |
[
"@view_config(route_name='new-note', permission='edit', renderer=...\n",
"VAR_2 = db.note.Note(None, user_id=request.user.user_id, content=request.\n params.get('note', ''))\n",
"if VAR_0.method == 'POST':\n",
"FUNC_5(VAR_2, VAR_0)\n",
"return dict(title='Ny anteckning', VAR_2=note)\n",
"return HTTPFound(location=request.route_url('notes'))\n"
] | [
"@view_config(route_name='new-note', permission='edit', renderer=...\n",
"note = db.note.Note(None, user_id=request.user.user_id, content=request.\n params.get('note', ''))\n",
"if request.method == 'POST':\n",
"_save_or_create_note(note, request)\n",
"return dict(title='Ny anteckning', note=note)\n",
"return HTTPFound(location=request.route_url('notes'))\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Condition",
"Expr'",
"Return'",
"Return'"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.