lines
sequencelengths 1
383
| raw_lines
sequencelengths 1
383
| label
sequencelengths 1
383
| type
sequencelengths 1
383
|
|---|---|---|---|
[
"def FUNC_2(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return format_html(\"\"\"<ul{0}>\n{1}\n</ul>\"\"\", flatatt(self.attrs),\n format_html_join('\\n', '<li>{0}</li>', ((force_text(w),) for w in self)))\n"
] | [
"def render(self):...\n",
"\"\"\"docstring\"\"\"\n",
"return format_html(\"\"\"<ul{0}>\n{1}\n</ul>\"\"\", flatatt(self.attrs),\n format_html_join('\\n', '<li>{0}</li>', ((force_text(w),) for w in self)))\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Return'"
] |
[
"def FUNC_25(self):...\n",
"return self._has_role(constants.ROLE_UPLOAD)\n"
] | [
"def role_upload(self):...\n",
"return self._has_role(constants.ROLE_UPLOAD)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_1(self):...\n",
"self.assertFormfield(models.Event, 'start_date', widgets.AdminDateWidget)\n"
] | [
"def testDateField(self):...\n",
"self.assertFormfield(models.Event, 'start_date', widgets.AdminDateWidget)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"import logging\n",
"import urllib.parse\n",
"from io import BytesIO\n",
"from typing import TYPE_CHECKING, Any, BinaryIO, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union\n",
"import treq\n",
"from canonicaljson import encode_canonical_json\n",
"from netaddr import IPAddress, IPSet\n",
"from prometheus_client import Counter\n",
"from zope.interface import implementer, provider\n",
"from OpenSSL import SSL\n",
"from OpenSSL.SSL import VERIFY_NONE\n",
"from twisted.internet import defer, error as twisted_error, protocol, ssl\n",
"from twisted.internet.interfaces import IAddress, IHostResolution, IReactorPluggableNameResolver, IResolutionReceiver\n",
"from twisted.internet.task import Cooperator\n",
"from twisted.python.failure import Failure\n",
"from twisted.web._newclient import ResponseDone\n",
"from twisted.web.client import Agent, HTTPConnectionPool, ResponseNeverReceived, readBody\n",
"from twisted.web.http import PotentialDataLoss\n",
"from twisted.web.http_headers import Headers\n",
"from twisted.web.iweb import IAgent, IBodyProducer, IResponse\n",
"from synapse.api.errors import Codes, HttpResponseException, SynapseError\n",
"from synapse.http import QuieterFileBodyProducer, RequestTimedOutError, redact_uri\n",
"from synapse.http.proxyagent import ProxyAgent\n",
"from synapse.logging.context import make_deferred_yieldable\n",
"from synapse.logging.opentracing import set_tag, start_active_span, tags\n",
"from synapse.util import json_decoder\n",
"from synapse.util.async_helpers import timeout_deferred\n",
"if TYPE_CHECKING:\n",
"from synapse.app.homeserver import HomeServer\n",
"VAR_0 = logging.getLogger(__name__)\n",
"VAR_1 = Counter('synapse_http_client_requests', '', ['method'])\n",
"VAR_2 = Counter('synapse_http_client_responses', '', ['method', 'code'])\n",
"VAR_3 = Union[Mapping[str, 'RawHeaderValue'], Mapping[bytes, 'RawHeaderValue']]\n",
"VAR_4 = Sequence[Union[str, bytes]]\n",
"VAR_5 = Union[str, bytes, Iterable[Union[str, bytes]]]\n",
"VAR_6 = Union[Mapping[str, VAR_5], Mapping[bytes, VAR_5]]\n",
"def FUNC_0(VAR_7: IPAddress, VAR_8: Optional[IPSet], VAR_9: IPSet) ->bool:...\n",
"\"\"\"docstring\"\"\"\n",
"if VAR_7 in VAR_9:\n",
"if VAR_8 is None or VAR_7 not in VAR_8:\n",
"return False\n",
"return True\n"
] | [
"import logging\n",
"import urllib.parse\n",
"from io import BytesIO\n",
"from typing import TYPE_CHECKING, Any, BinaryIO, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union\n",
"import treq\n",
"from canonicaljson import encode_canonical_json\n",
"from netaddr import IPAddress, IPSet\n",
"from prometheus_client import Counter\n",
"from zope.interface import implementer, provider\n",
"from OpenSSL import SSL\n",
"from OpenSSL.SSL import VERIFY_NONE\n",
"from twisted.internet import defer, error as twisted_error, protocol, ssl\n",
"from twisted.internet.interfaces import IAddress, IHostResolution, IReactorPluggableNameResolver, IResolutionReceiver\n",
"from twisted.internet.task import Cooperator\n",
"from twisted.python.failure import Failure\n",
"from twisted.web._newclient import ResponseDone\n",
"from twisted.web.client import Agent, HTTPConnectionPool, ResponseNeverReceived, readBody\n",
"from twisted.web.http import PotentialDataLoss\n",
"from twisted.web.http_headers import Headers\n",
"from twisted.web.iweb import IAgent, IBodyProducer, IResponse\n",
"from synapse.api.errors import Codes, HttpResponseException, SynapseError\n",
"from synapse.http import QuieterFileBodyProducer, RequestTimedOutError, redact_uri\n",
"from synapse.http.proxyagent import ProxyAgent\n",
"from synapse.logging.context import make_deferred_yieldable\n",
"from synapse.logging.opentracing import set_tag, start_active_span, tags\n",
"from synapse.util import json_decoder\n",
"from synapse.util.async_helpers import timeout_deferred\n",
"if TYPE_CHECKING:\n",
"from synapse.app.homeserver import HomeServer\n",
"logger = logging.getLogger(__name__)\n",
"outgoing_requests_counter = Counter('synapse_http_client_requests', '', [\n 'method'])\n",
"incoming_responses_counter = Counter('synapse_http_client_responses', '', [\n 'method', 'code'])\n",
"RawHeaders = Union[Mapping[str, 'RawHeaderValue'], Mapping[bytes,\n 'RawHeaderValue']]\n",
"RawHeaderValue = Sequence[Union[str, bytes]]\n",
"QueryParamValue = Union[str, bytes, Iterable[Union[str, bytes]]]\n",
"QueryParams = Union[Mapping[str, QueryParamValue], Mapping[bytes,\n QueryParamValue]]\n",
"def check_against_blacklist(ip_address: IPAddress, ip_whitelist: Optional[...\n",
"\"\"\"docstring\"\"\"\n",
"if ip_address in ip_blacklist:\n",
"if ip_whitelist is None or ip_address not in ip_whitelist:\n",
"return False\n",
"return True\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,
0,
0,
0,
0,
0,
0
] | [
"Import'",
"Import'",
"ImportFrom'",
"ImportFrom'",
"Import'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"Condition",
"ImportFrom'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"FunctionDef'",
"Docstring",
"Condition",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_38(self):...\n",
"from zope.interface.verify import verifyClass\n",
"from zope.tal.interfaces import ITALExpressionEngine\n",
"verifyClass(ITALExpressionEngine, self._getTargetClass())\n"
] | [
"def test_class_conforms_to_ITALExpressionEngine(self):...\n",
"from zope.interface.verify import verifyClass\n",
"from zope.tal.interfaces import ITALExpressionEngine\n",
"verifyClass(ITALExpressionEngine, self._getTargetClass())\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"ImportFrom'",
"ImportFrom'",
"Expr'"
] |
[
"@login_required()...\n",
""
] | [
"@login_required()...\n",
""
] | [
0,
0
] | [
"Condition",
"Condition"
] |
[
"\"\"\"\nForm Widget classes specific to the Django admin site.\n\"\"\"\n",
"from __future__ import unicode_literals\n",
"import copy\n",
"from django import forms\n",
"from django.contrib.admin.templatetags.admin_static import static\n",
"from django.core.urlresolvers import reverse\n",
"from django.forms.widgets import RadioFieldRenderer\n",
"from django.forms.util import flatatt\n",
"from django.utils.html import escape, format_html, format_html_join, smart_urlquote\n",
"from django.utils.text import Truncator\n",
"from django.utils.translation import ugettext as _\n",
"from django.utils.safestring import mark_safe\n",
"from django.utils.encoding import force_text\n",
"from django.utils import six\n",
"\"\"\"string\"\"\"\n",
"@property...\n",
"VAR_26 = ['core.js', 'SelectBox.js', 'SelectFilter2.js']\n",
"return forms.Media(VAR_26=[static('admin/js/%s' % path) for path in js])\n"
] | [
"\"\"\"\nForm Widget classes specific to the Django admin site.\n\"\"\"\n",
"from __future__ import unicode_literals\n",
"import copy\n",
"from django import forms\n",
"from django.contrib.admin.templatetags.admin_static import static\n",
"from django.core.urlresolvers import reverse\n",
"from django.forms.widgets import RadioFieldRenderer\n",
"from django.forms.util import flatatt\n",
"from django.utils.html import escape, format_html, format_html_join, smart_urlquote\n",
"from django.utils.text import Truncator\n",
"from django.utils.translation import ugettext as _\n",
"from django.utils.safestring import mark_safe\n",
"from django.utils.encoding import force_text\n",
"from django.utils import six\n",
"\"\"\"\n A SelectMultiple with a JavaScript filter interface.\n\n Note that the resulting JavaScript assumes that the jsi18n\n catalog has been loaded in the page\n \"\"\"\n",
"@property...\n",
"js = ['core.js', 'SelectBox.js', 'SelectFilter2.js']\n",
"return forms.Media(js=[static('admin/js/%s' % path) for path in js])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Expr'",
"ImportFrom'",
"Import'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"Expr'",
"Condition",
"Assign'",
"Return'"
] |
[
"async def FUNC_6(*VAR_9, **VAR_10):...\n",
"return None\n"
] | [
"async def _insert_client_ip(*args, **kwargs):...\n",
"return None\n"
] | [
0,
0
] | [
"AsyncFunctionDef'",
"Return'"
] |
[
"def FUNC_88(VAR_212):...\n",
"VAR_408 = VAR_5.getAnnotationLinks('Image', parent_ids=imageIds)\n",
"VAR_409 = {}\n",
"VAR_410 = {}\n",
"for VAR_432 in VAR_212:\n",
"VAR_409[VAR_432] = []\n",
"for VAR_344 in VAR_408:\n",
"VAR_383 = VAR_344.getChild()\n",
"VAR_411 = []\n",
"if VAR_383._obj.__class__ == omero.model.TagAnnotationI:\n",
"for VAR_432 in VAR_212:\n",
"VAR_410[VAR_383.id] = VAR_383\n",
"VAR_411.append({'id': VAR_432, 'tags': VAR_409[VAR_432]})\n",
"VAR_164 = []\n",
"VAR_409[VAR_344.getParent().id].append(VAR_383)\n",
"for tId, VAR_433 in VAR_410.items():\n",
"VAR_164.append(VAR_433)\n",
"return VAR_411, VAR_164\n"
] | [
"def loadImageTags(imageIds):...\n",
"tagLinks = conn.getAnnotationLinks('Image', parent_ids=imageIds)\n",
"linkMap = {}\n",
"tagMap = {}\n",
"for iId in imageIds:\n",
"linkMap[iId] = []\n",
"for link in tagLinks:\n",
"c = link.getChild()\n",
"imageTags = []\n",
"if c._obj.__class__ == omero.model.TagAnnotationI:\n",
"for iId in imageIds:\n",
"tagMap[c.id] = c\n",
"imageTags.append({'id': iId, 'tags': linkMap[iId]})\n",
"tags = []\n",
"linkMap[link.getParent().id].append(c)\n",
"for tId, t in tagMap.items():\n",
"tags.append(t)\n",
"return imageTags, tags\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Assign'",
"For",
"Assign'",
"Assign'",
"Condition",
"For",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"For",
"Expr'",
"Return'"
] |
[
"def FUNC_14(VAR_3):...\n",
"\"\"\"docstring\"\"\"\n",
"if not VAR_16:\n",
"if VAR_13.get('logging') or False:\n",
"VAR_21.append(FUNC_1(VAR_3))\n",
"print(repr(VAR_3))\n"
] | [
"def log(msg):...\n",
"\"\"\"docstring\"\"\"\n",
"if not request:\n",
"if conf.get('logging') or False:\n",
"debug_log.append(as_unicode(msg))\n",
"print(repr(msg))\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_5(self):...\n",
"conditional.processConditionals(self)\n",
"self.fillContainers = locateFillContainers(self)\n",
"lint.exampleIDs(self)\n",
"boilerplate.addBikeshedVersion(self)\n",
"boilerplate.addCanonicalURL(self)\n",
"boilerplate.addFavicon(self)\n",
"boilerplate.addSpecVersion(self)\n",
"boilerplate.addStatusSection(self)\n",
"boilerplate.addLogo(self)\n",
"boilerplate.addCopyright(self)\n",
"boilerplate.addSpecMetadataSection(self)\n",
"boilerplate.addAbstract(self)\n",
"boilerplate.addExpiryNotice(self)\n",
"boilerplate.addObsoletionNotice(self)\n",
"boilerplate.addAtRisk(self)\n",
"addNoteHeaders(self)\n",
"boilerplate.removeUnwantedBoilerplate(self)\n",
"wpt.processWptElements(self)\n",
"shorthands.run(self)\n",
"inlineTags.processTags(self)\n",
"canonicalizeShortcuts(self)\n",
"addImplicitAlgorithms(self)\n",
"fixManualDefTables(self)\n",
"headings.processHeadings(self)\n",
"checkVarHygiene(self)\n",
"processIssuesAndExamples(self)\n",
"idl.markupIDL(self)\n",
"inlineRemoteIssues(self)\n",
"addImageSize(self)\n",
"processBiblioLinks(self)\n",
"processDfns(self)\n",
"idl.processIDL(self)\n",
"dfns.annotateDfns(self)\n",
"formatArgumentdefTables(self)\n",
"formatElementdefTables(self)\n",
"processAutolinks(self)\n",
"biblio.dedupBiblioReferences(self)\n",
"verifyUsageOfAllLocalBiblios(self)\n",
"caniuse.addCanIUsePanels(self)\n",
"boilerplate.addIndexSection(self)\n",
"boilerplate.addExplicitIndexes(self)\n",
"boilerplate.addStyles(self)\n",
"boilerplate.addReferencesSection(self)\n",
"boilerplate.addPropertyIndex(self)\n",
"boilerplate.addIDLSection(self)\n",
"boilerplate.addIssuesSection(self)\n",
"boilerplate.addCustomBoilerplate(self)\n",
"headings.processHeadings(self, 'all')\n",
"boilerplate.removeUnwantedBoilerplate(self)\n",
"boilerplate.addTOCSection(self)\n",
"addSelfLinks(self)\n",
"processAutolinks(self)\n",
"boilerplate.addAnnotations(self)\n",
"boilerplate.removeUnwantedBoilerplate(self)\n",
"mdnspeclinks.addMdnPanels(self)\n",
"highlight.addSyntaxHighlighting(self)\n",
"boilerplate.addBikeshedBoilerplate(self)\n",
"fingerprinting.addTrackingVector(self)\n",
"fixIntraDocumentReferences(self)\n",
"fixInterDocumentReferences(self)\n",
"removeMultipleLinks(self)\n",
"forceCrossorigin(self)\n",
"lint.brokenLinks(self)\n",
"lint.accidental2119(self)\n",
"lint.missingExposed(self)\n",
"lint.requiredIDs(self)\n",
"lint.unusedInternalDfns(self)\n",
"cleanupHTML(self)\n",
"if self.md.prepTR:\n",
"for VAR_19 in findAll(\"[rel ~= 'icon']\", self):\n",
"return self\n",
"removeNode(VAR_19)\n",
"for VAR_19 in findAll('link', self):\n",
"if VAR_19.get('href').startswith('https://www.w3.org/StyleSheets/TR'):\n",
"for VAR_19 in findAll('a', self):\n",
"appendChild(find('head', self), VAR_19)\n",
"VAR_35 = VAR_19.get('href', '')\n",
"extensions.BSPrepTR(self)\n",
"if VAR_35.startswith('http://www.w3.org') or VAR_35.startswith(\n",
"VAR_19.set('href', 'https' + VAR_35[4:])\n",
"VAR_17 = VAR_19.text or ''\n",
"if VAR_17.startswith('http://www.w3.org') or VAR_17.startswith(\n",
"VAR_19.text = 'https' + VAR_17[4:]\n"
] | [
"def processDocument(self):...\n",
"conditional.processConditionals(self)\n",
"self.fillContainers = locateFillContainers(self)\n",
"lint.exampleIDs(self)\n",
"boilerplate.addBikeshedVersion(self)\n",
"boilerplate.addCanonicalURL(self)\n",
"boilerplate.addFavicon(self)\n",
"boilerplate.addSpecVersion(self)\n",
"boilerplate.addStatusSection(self)\n",
"boilerplate.addLogo(self)\n",
"boilerplate.addCopyright(self)\n",
"boilerplate.addSpecMetadataSection(self)\n",
"boilerplate.addAbstract(self)\n",
"boilerplate.addExpiryNotice(self)\n",
"boilerplate.addObsoletionNotice(self)\n",
"boilerplate.addAtRisk(self)\n",
"addNoteHeaders(self)\n",
"boilerplate.removeUnwantedBoilerplate(self)\n",
"wpt.processWptElements(self)\n",
"shorthands.run(self)\n",
"inlineTags.processTags(self)\n",
"canonicalizeShortcuts(self)\n",
"addImplicitAlgorithms(self)\n",
"fixManualDefTables(self)\n",
"headings.processHeadings(self)\n",
"checkVarHygiene(self)\n",
"processIssuesAndExamples(self)\n",
"idl.markupIDL(self)\n",
"inlineRemoteIssues(self)\n",
"addImageSize(self)\n",
"processBiblioLinks(self)\n",
"processDfns(self)\n",
"idl.processIDL(self)\n",
"dfns.annotateDfns(self)\n",
"formatArgumentdefTables(self)\n",
"formatElementdefTables(self)\n",
"processAutolinks(self)\n",
"biblio.dedupBiblioReferences(self)\n",
"verifyUsageOfAllLocalBiblios(self)\n",
"caniuse.addCanIUsePanels(self)\n",
"boilerplate.addIndexSection(self)\n",
"boilerplate.addExplicitIndexes(self)\n",
"boilerplate.addStyles(self)\n",
"boilerplate.addReferencesSection(self)\n",
"boilerplate.addPropertyIndex(self)\n",
"boilerplate.addIDLSection(self)\n",
"boilerplate.addIssuesSection(self)\n",
"boilerplate.addCustomBoilerplate(self)\n",
"headings.processHeadings(self, 'all')\n",
"boilerplate.removeUnwantedBoilerplate(self)\n",
"boilerplate.addTOCSection(self)\n",
"addSelfLinks(self)\n",
"processAutolinks(self)\n",
"boilerplate.addAnnotations(self)\n",
"boilerplate.removeUnwantedBoilerplate(self)\n",
"mdnspeclinks.addMdnPanels(self)\n",
"highlight.addSyntaxHighlighting(self)\n",
"boilerplate.addBikeshedBoilerplate(self)\n",
"fingerprinting.addTrackingVector(self)\n",
"fixIntraDocumentReferences(self)\n",
"fixInterDocumentReferences(self)\n",
"removeMultipleLinks(self)\n",
"forceCrossorigin(self)\n",
"lint.brokenLinks(self)\n",
"lint.accidental2119(self)\n",
"lint.missingExposed(self)\n",
"lint.requiredIDs(self)\n",
"lint.unusedInternalDfns(self)\n",
"cleanupHTML(self)\n",
"if self.md.prepTR:\n",
"for el in findAll(\"[rel ~= 'icon']\", self):\n",
"return self\n",
"removeNode(el)\n",
"for el in findAll('link', self):\n",
"if el.get('href').startswith('https://www.w3.org/StyleSheets/TR'):\n",
"for el in findAll('a', self):\n",
"appendChild(find('head', self), el)\n",
"href = el.get('href', '')\n",
"extensions.BSPrepTR(self)\n",
"if href.startswith('http://www.w3.org') or href.startswith(\n",
"el.set('href', 'https' + href[4:])\n",
"text = el.text or ''\n",
"if text.startswith('http://www.w3.org') or text.startswith(\n",
"el.text = 'https' + text[4:]\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,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Condition",
"For",
"Return'",
"Expr'",
"For",
"Condition",
"For",
"Expr'",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Assign'"
] |
[
"@wraps(VAR_4)...\n",
"if VAR_87.role_viewer():\n",
"return VAR_4(*VAR_49, **kwargs)\n",
"abort(403)\n"
] | [
"@wraps(f)...\n",
"if current_user.role_viewer():\n",
"return f(*args, **kwargs)\n",
"abort(403)\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Expr'"
] |
[
"def FUNC_0(self):...\n",
"from openapi_python_client.parser.properties import StringProperty\n",
"VAR_4 = VAR_35(VAR_5='test', VAR_26=True, default=None)\n",
"assert VAR_4.get_type_string() == 'str'\n",
"VAR_4.required = False\n",
"assert VAR_4.get_type_string() == 'Optional[str]'\n"
] | [
"def test_get_type_string(self):...\n",
"from openapi_python_client.parser.properties import StringProperty\n",
"p = StringProperty(name='test', required=True, default=None)\n",
"assert p.get_type_string() == 'str'\n",
"p.required = False\n",
"assert p.get_type_string() == 'Optional[str]'\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"ImportFrom'",
"Assign'",
"Assert'",
"Assign'",
"Assert'"
] |
[
"def FUNC_26(self, VAR_15, **VAR_14):...\n",
"\"\"\"docstring\"\"\"\n",
"if VAR_15.status_code == 401:\n",
"VAR_1.warning('401 Error, Credentials not correct for %s', VAR_15.request.url)\n"
] | [
"def warn_on_401(self, resp, **kwargs):...\n",
"\"\"\"docstring\"\"\"\n",
"if resp.status_code == 401:\n",
"logger.warning('401 Error, Credentials not correct for %s', resp.request.url)\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Expr'"
] |
[
"@override_config({'send_federation': True})...\n",
"self.room_members = [VAR_0, VAR_1, VAR_2]\n",
"from synapse.handlers.typing import RoomMember\n",
"VAR_22 = RoomMember(VAR_3, VAR_0.to_string())\n",
"self.handler._member_typing_until[VAR_22] = 1002000\n",
"self.handler._room_typing[VAR_3] = {VAR_0.to_string()}\n",
"self.assertEquals(self.event_source.get_current_key(), 0)\n",
"self.get_success(self.handler.stopped_typing(target_user=U_APPLE, requester\n =create_requester(U_APPLE), VAR_16=ROOM_ID))\n",
"self.on_new_event.assert_has_calls([call('typing_key', 1, rooms=[ROOM_ID])])\n",
"VAR_19 = self.hs.get_http_client().put_json\n",
"VAR_19.assert_called_once_with('farm', path=\n '/_matrix/federation/v1/send/1000000', data=_expect_edu_transaction(\n 'm.typing', content={'room_id': ROOM_ID, 'user_id': U_APPLE.to_string(),\n 'typing': False}), json_data_callback=ANY, long_retries=True,\n backoff_on_404=True, try_trailing_slash_on_400=True)\n",
"self.assertEquals(self.event_source.get_current_key(), 1)\n",
"VAR_18 = self.get_success(self.event_source.get_new_events(room_ids=[\n ROOM_ID], from_key=0))\n",
"self.assertEquals(VAR_18[0], [{'type': 'm.typing', 'room_id': VAR_3,\n 'content': {'user_ids': []}}])\n"
] | [
"@override_config({'send_federation': True})...\n",
"self.room_members = [U_APPLE, U_BANANA, U_ONION]\n",
"from synapse.handlers.typing import RoomMember\n",
"member = RoomMember(ROOM_ID, U_APPLE.to_string())\n",
"self.handler._member_typing_until[member] = 1002000\n",
"self.handler._room_typing[ROOM_ID] = {U_APPLE.to_string()}\n",
"self.assertEquals(self.event_source.get_current_key(), 0)\n",
"self.get_success(self.handler.stopped_typing(target_user=U_APPLE, requester\n =create_requester(U_APPLE), room_id=ROOM_ID))\n",
"self.on_new_event.assert_has_calls([call('typing_key', 1, rooms=[ROOM_ID])])\n",
"put_json = self.hs.get_http_client().put_json\n",
"put_json.assert_called_once_with('farm', path=\n '/_matrix/federation/v1/send/1000000', data=_expect_edu_transaction(\n 'm.typing', content={'room_id': ROOM_ID, 'user_id': U_APPLE.to_string(),\n 'typing': False}), json_data_callback=ANY, long_retries=True,\n backoff_on_404=True, try_trailing_slash_on_400=True)\n",
"self.assertEquals(self.event_source.get_current_key(), 1)\n",
"events = self.get_success(self.event_source.get_new_events(room_ids=[\n ROOM_ID], from_key=0))\n",
"self.assertEquals(events[0], [{'type': 'm.typing', 'room_id': ROOM_ID,\n 'content': {'user_ids': []}}])\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
4,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"ImportFrom'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"def FUNC_30(VAR_27):...\n",
"print(VAR_26 + VAR_27)\n"
] | [
"def in_print(s):...\n",
"print(indent_str + s)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def __init__(self, VAR_8, *VAR_6, **VAR_7):...\n",
"super().__init__(*VAR_6, **kwargs)\n",
"self.fields['lang'].choices += Language.objects.have_translation().as_choices()\n",
"self.fields['project'].choices += [(VAR_58.slug, VAR_58.name) for VAR_58 in\n VAR_8.user.allowed_projects]\n"
] | [
"def __init__(self, request, *args, **kwargs):...\n",
"super().__init__(*args, **kwargs)\n",
"self.fields['lang'].choices += Language.objects.have_translation().as_choices()\n",
"self.fields['project'].choices += [(project.slug, project.name) for project in\n request.user.allowed_projects]\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"AugAssign'",
"AugAssign'"
] |
[
"import re\n",
"import stringcase\n",
"def FUNC_0(VAR_0: str) ->str:...\n",
"return re.sub('[^\\\\w _-]+', '', VAR_0)\n"
] | [
"import re\n",
"import stringcase\n",
"def _sanitize(value: str) ->str:...\n",
"return re.sub('[^\\\\w _-]+', '', value)\n"
] | [
0,
0,
0,
5
] | [
"Import'",
"Import'",
"FunctionDef'",
"Return'"
] |
[
"@pytest.mark.posix...\n",
"assert filescheme.parent_dir(VAR_9) == VAR_11\n"
] | [
"@pytest.mark.posix...\n",
"assert filescheme.parent_dir(directory) == parent\n"
] | [
0,
0
] | [
"Condition",
"Assert'"
] |
[
"def FUNC_1(VAR_2):...\n",
"@wraps(VAR_2)...\n",
"if current_user.role_edit() or current_user.role_admin():\n",
"return VAR_2(*VAR_48, **kwargs)\n",
"abort(403)\n",
"return FUNC_46\n"
] | [
"def edit_required(f):...\n",
"@wraps(f)...\n",
"if current_user.role_edit() or current_user.role_admin():\n",
"return f(*args, **kwargs)\n",
"abort(403)\n",
"return inner\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Condition",
"Return'",
"Expr'",
"Return'"
] |
[
"def FUNC_22(self):...\n",
"VAR_5 = self._makeContext()\n",
"self.assertEqual(VAR_5.evaluate('path:'), None)\n"
] | [
"def test_empty_path_expression_explicit(self):...\n",
"ec = self._makeContext()\n",
"self.assertEqual(ec.evaluate('path:'), None)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'"
] |
[
"def FUNC_156():...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_355 = {'prefix': VAR_113, 'user': VAR_116 if self.user_id else None}\n",
"for i in VAR_250:\n",
"if i['name'] == VAR_28('Log In'):\n",
"self.bar = VAR_355\n",
"VAR_346 = 'login'\n",
"if i['name'] == VAR_28('Sign Up'):\n",
"VAR_355[VAR_346] = i['href']\n",
"VAR_346 = 'register'\n",
"if i['name'] == VAR_28('Lost password?'):\n",
"VAR_346 = 'request_reset_password'\n",
"if i['name'] == VAR_28('Forgot username?'):\n",
"VAR_346 = 'retrieve_username'\n",
"if i['name'] == VAR_28('Log Out'):\n",
"VAR_346 = 'logout'\n",
"if i['name'] == VAR_28('Profile'):\n",
"VAR_346 = 'profile'\n",
"if i['name'] == VAR_28('Password'):\n",
"VAR_346 = 'change_password'\n"
] | [
"def bare():...\n",
"\"\"\"docstring\"\"\"\n",
"bare = {'prefix': prefix, 'user': user_identifier if self.user_id else None}\n",
"for i in items:\n",
"if i['name'] == T('Log In'):\n",
"self.bar = bare\n",
"k = 'login'\n",
"if i['name'] == T('Sign Up'):\n",
"bare[k] = i['href']\n",
"k = 'register'\n",
"if i['name'] == T('Lost password?'):\n",
"k = 'request_reset_password'\n",
"if i['name'] == T('Forgot username?'):\n",
"k = 'retrieve_username'\n",
"if i['name'] == T('Log Out'):\n",
"k = 'logout'\n",
"if i['name'] == T('Profile'):\n",
"k = 'profile'\n",
"if i['name'] == T('Password'):\n",
"k = 'change_password'\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"For",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'"
] |
[
"@log_function...\n",
"VAR_142 = {'signed': VAR_44}\n",
"VAR_45 = {'type': VAR_188.Member, 'content': {'membership': Membership.\n INVITE, 'third_party_invite': VAR_142}, 'room_id': VAR_11, 'sender':\n VAR_42, 'state_key': VAR_43}\n",
"if await self.auth.check_host_in_room(VAR_11, self.hs.hostname):\n",
"VAR_28 = await self.store.get_room_version_id(VAR_11)\n",
"VAR_181 = {VAR_204.split(':', 1)[-1] for VAR_204 in (VAR_42, VAR_11)}\n",
"VAR_93 = self.event_builder_factory.new(VAR_28, VAR_45)\n",
"await self.federation_client.forward_third_party_invite(VAR_181, VAR_11, VAR_45\n )\n",
"EventValidator().validate_builder(VAR_93)\n",
"VAR_1, VAR_32 = await self.event_creation_handler.create_new_client_event(\n VAR_93=builder)\n",
"VAR_1, VAR_32 = await self.add_display_name_to_third_party_invite(VAR_28,\n VAR_45, VAR_1, VAR_32)\n",
"EventValidator().validate_new(VAR_1, self.config)\n",
"VAR_1.internal_metadata.send_on_behalf_of = self.hs.hostname\n",
"await self.auth.check_from_context(VAR_28, VAR_1, VAR_32)\n",
"VAR_0.warning('Denying new third party invite %r because %s', VAR_1, VAR_170)\n",
"await self._check_signature(VAR_1, VAR_32)\n",
"VAR_143 = self.hs.get_room_member_handler()\n",
"await VAR_143.send_membership_event(None, VAR_1, VAR_32)\n"
] | [
"@log_function...\n",
"third_party_invite = {'signed': signed}\n",
"event_dict = {'type': EventTypes.Member, 'content': {'membership':\n Membership.INVITE, 'third_party_invite': third_party_invite}, 'room_id':\n room_id, 'sender': sender_user_id, 'state_key': target_user_id}\n",
"if await self.auth.check_host_in_room(room_id, self.hs.hostname):\n",
"room_version = await self.store.get_room_version_id(room_id)\n",
"destinations = {x.split(':', 1)[-1] for x in (sender_user_id, room_id)}\n",
"builder = self.event_builder_factory.new(room_version, event_dict)\n",
"await self.federation_client.forward_third_party_invite(destinations,\n room_id, event_dict)\n",
"EventValidator().validate_builder(builder)\n",
"event, context = await self.event_creation_handler.create_new_client_event(\n builder=builder)\n",
"event, context = await self.add_display_name_to_third_party_invite(room_version\n , event_dict, event, context)\n",
"EventValidator().validate_new(event, self.config)\n",
"event.internal_metadata.send_on_behalf_of = self.hs.hostname\n",
"await self.auth.check_from_context(room_version, event, context)\n",
"logger.warning('Denying new third party invite %r because %s', event, e)\n",
"await self._check_signature(event, context)\n",
"member_handler = self.hs.get_room_member_handler()\n",
"await member_handler.send_membership_event(None, event, context)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"@log_function...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_2 = FUNC_1('/user/keys/query')\n",
"VAR_19 = await self.client.post_json(VAR_5=destination, VAR_2=path, VAR_39=\n query_content, VAR_8=timeout)\n",
"return VAR_19\n"
] | [
"@log_function...\n",
"\"\"\"docstring\"\"\"\n",
"path = _create_v1_path('/user/keys/query')\n",
"content = await self.client.post_json(destination=destination, path=path,\n data=query_content, timeout=timeout)\n",
"return content\n"
] | [
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_8(self, VAR_4):...\n",
"self.get_success(self.store.create_room_alias_association(self.room_alias,\n self.room_id, ['test'], VAR_4))\n"
] | [
"def _create_alias(self, user):...\n",
"self.get_success(self.store.create_room_alias_association(self.room_alias,\n self.room_id, ['test'], user))\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"@ensure_csrf_cookie...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_10 = SlashSeparatedCourseKey.from_deprecated_string(VAR_10)\n",
"VAR_65 = get_course_by_id(VAR_10)\n",
"VAR_136 = has_access(VAR_9.user, 'instructor', VAR_65)\n",
"VAR_137 = has_forum_access(VAR_9.user, VAR_10, FORUM_ROLE_ADMINISTRATOR)\n",
"VAR_141 = VAR_9.GET.get('unique_student_identifier')\n",
"VAR_64 = VAR_9.GET.get('rolename')\n",
"VAR_57 = VAR_9.GET.get('action')\n",
"if not (VAR_137 or VAR_136):\n",
"return HttpResponseBadRequest(\n 'Operation requires staff & forum admin or instructor access')\n",
"if VAR_64 == FORUM_ROLE_ADMINISTRATOR and not VAR_136:\n",
"return HttpResponseBadRequest('Operation requires instructor access.')\n",
"if VAR_64 not in [FORUM_ROLE_ADMINISTRATOR, FORUM_ROLE_MODERATOR,\n",
"return HttpResponseBadRequest(strip_tags(\"Unrecognized rolename '{}'.\".\n format(VAR_64)))\n",
"VAR_19 = get_student_from_identifier(VAR_141)\n",
"update_forum_role(VAR_10, VAR_19, VAR_64, VAR_57)\n",
"return HttpResponseBadRequest('Role does not exist.')\n",
"VAR_63 = {'course_id': VAR_10.to_deprecated_string(), 'action': VAR_57}\n",
"return JsonResponse(VAR_63)\n"
] | [
"@ensure_csrf_cookie...\n",
"\"\"\"docstring\"\"\"\n",
"course_id = SlashSeparatedCourseKey.from_deprecated_string(course_id)\n",
"course = get_course_by_id(course_id)\n",
"has_instructor_access = has_access(request.user, 'instructor', course)\n",
"has_forum_admin = has_forum_access(request.user, course_id,\n FORUM_ROLE_ADMINISTRATOR)\n",
"unique_student_identifier = request.GET.get('unique_student_identifier')\n",
"rolename = request.GET.get('rolename')\n",
"action = request.GET.get('action')\n",
"if not (has_forum_admin or has_instructor_access):\n",
"return HttpResponseBadRequest(\n 'Operation requires staff & forum admin or instructor access')\n",
"if rolename == FORUM_ROLE_ADMINISTRATOR and not has_instructor_access:\n",
"return HttpResponseBadRequest('Operation requires instructor access.')\n",
"if rolename not in [FORUM_ROLE_ADMINISTRATOR, FORUM_ROLE_MODERATOR,\n",
"return HttpResponseBadRequest(strip_tags(\"Unrecognized rolename '{}'.\".\n format(rolename)))\n",
"user = get_student_from_identifier(unique_student_identifier)\n",
"update_forum_role(course_id, user, rolename, action)\n",
"return HttpResponseBadRequest('Role does not exist.')\n",
"response_payload = {'course_id': course_id.to_deprecated_string(), 'action':\n action}\n",
"return JsonResponse(response_payload)\n"
] | [
0,
0,
0,
0,
0,
0,
3,
3,
3,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Return'",
"Condition",
"Return'",
"Condition",
"Return'",
"Assign'",
"Expr'",
"Return'",
"Assign'",
"Return'"
] |
[
"@def_function.function...\n",
"return VAR_49 + 2 * VAR_55\n"
] | [
"@def_function.function...\n",
"return y + 2 * c\n"
] | [
0,
0
] | [
"Condition",
"Return'"
] |
[
"def FUNC_70(VAR_12, VAR_29):...\n",
"VAR_95 = FUNC_69(VAR_12, VAR_29)\n",
"return FUNC_68(VAR_12, VAR_95)\n"
] | [
"def extract_user_identifier(user, filtr):...\n",
"dynamic_field = extract_dynamic_field_from_filter(user, filtr)\n",
"return extract_user_data_from_field(user, dynamic_field)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_0(VAR_2: str, VAR_3: pathlib.Path) ->pathlib.Path:...\n",
"VAR_12 = (VAR_3 / VAR_2).absolute()\n",
"if not str(VAR_12).startswith(str(VAR_3) + '/'):\n",
"return VAR_12\n"
] | [
"def sanitized_join(path: str, root: pathlib.Path) ->pathlib.Path:...\n",
"result = (root / path).absolute()\n",
"if not str(result).startswith(str(root) + '/'):\n",
"return result\n"
] | [
0,
1,
1,
1
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Return'"
] |
[
"def FUNC_0(VAR_5):...\n",
"if VAR_3(VAR_5):\n",
"return None\n",
"return VAR_4(VAR_5)\n"
] | [
"def _is_javascript_scheme(s):...\n",
"if _is_image_dataurl(s):\n",
"return None\n",
"return _is_possibly_malicious_scheme(s)\n"
] | [
0,
2,
2,
2
] | [
"FunctionDef'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_18(self, VAR_17, VAR_18):...\n",
"if not VAR_53.session['admin']:\n",
"VAR_66 = albumArtFilePath(VAR_17)\n",
"VAR_64 = albumartfetcher.AlbumArtFetcher()\n",
"VAR_20, VAR_67 = VAR_64.retrieveData(VAR_18)\n",
"self.albumartcache_save(VAR_66, VAR_20)\n"
] | [
"def api_albumart_set(self, directory, imageurl):...\n",
"if not cherrypy.session['admin']:\n",
"b64imgpath = albumArtFilePath(directory)\n",
"fetcher = albumartfetcher.AlbumArtFetcher()\n",
"data, header = fetcher.retrieveData(imageurl)\n",
"self.albumartcache_save(b64imgpath, data)\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_4(VAR_6: EscapableEntity) ->str:...\n",
"\"\"\"docstring\"\"\"\n",
"if isinstance(VAR_6, HTML):\n",
"VAR_6 = VAR_6.__html__()\n",
"if not isinstance(VAR_6, str):\n",
"return u'%s' % VAR_6\n",
"VAR_6 = ensure_str(VAR_6)\n",
"while True:\n",
"VAR_9 = VAR_6.find('<')\n",
"if VAR_9 == -1:\n",
"VAR_10 = VAR_6.find('>', VAR_9)\n",
"return VAR_6.replace(' ', ' ')\n",
"if VAR_10 == -1:\n",
"VAR_6 = VAR_6[0:VAR_9] + VAR_6[VAR_10 + 1:]\n"
] | [
"def strip_tags(ht: EscapableEntity) ->str:...\n",
"\"\"\"docstring\"\"\"\n",
"if isinstance(ht, HTML):\n",
"ht = ht.__html__()\n",
"if not isinstance(ht, str):\n",
"return u'%s' % ht\n",
"ht = ensure_str(ht)\n",
"while True:\n",
"x = ht.find('<')\n",
"if x == -1:\n",
"y = ht.find('>', x)\n",
"return ht.replace(' ', ' ')\n",
"if y == -1:\n",
"ht = ht[0:x] + ht[y + 1:]\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Assign'",
"Condition",
"Return'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Condition",
"Assign'"
] |
[
"def FUNC_3(self, VAR_5, *VAR_6, **VAR_4):...\n",
"VAR_16 = VAR_5.POST.get('command')\n",
"if VAR_16:\n",
"VAR_24 = getattr(self, 'dispatch_%s' % VAR_16, None)\n",
"if VAR_5.POST.get('save') and self.form and self.form.is_valid():\n",
"if not callable(VAR_24):\n",
"self.form.save()\n",
"return self.get(VAR_5, *VAR_6, **kwargs)\n",
"VAR_25 = dict(VAR_5.POST.items())\n",
"self.save_layout()\n",
"VAR_26 = VAR_24(**dispatch_kwargs)\n",
"self.build_form()\n",
"if VAR_26:\n",
"if VAR_5.POST.get('publish') == '1':\n",
"return VAR_26\n",
"self.request.method = 'GET'\n",
"return self.dispatch_publish()\n",
"self.build_form()\n",
"return super(CLASS_0, self).get(VAR_5, *VAR_6, **kwargs)\n"
] | [
"def post(self, request, *args, **kwargs):...\n",
"command = request.POST.get('command')\n",
"if command:\n",
"dispatcher = getattr(self, 'dispatch_%s' % command, None)\n",
"if request.POST.get('save') and self.form and self.form.is_valid():\n",
"if not callable(dispatcher):\n",
"self.form.save()\n",
"return self.get(request, *args, **kwargs)\n",
"dispatch_kwargs = dict(request.POST.items())\n",
"self.save_layout()\n",
"rv = dispatcher(**dispatch_kwargs)\n",
"self.build_form()\n",
"if rv:\n",
"if request.POST.get('publish') == '1':\n",
"return rv\n",
"self.request.method = 'GET'\n",
"return self.dispatch_publish()\n",
"self.build_form()\n",
"return super(EditorView, self).get(request, *args, **kwargs)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Assign'",
"For",
"Condition",
"Expr'",
"Return'",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Condition",
"Condition",
"Return'",
"Assign'",
"Return'",
"Expr'",
"Return'"
] |
[
"@action('copyrole', lazy_gettext('Copy Role'), lazy_gettext(...\n",
"self.update_redirect()\n",
"for VAR_21 in VAR_33:\n",
"VAR_49 = VAR_21.__class__()\n",
"return redirect(self.get_redirect())\n",
"VAR_49.name = VAR_21.name\n",
"VAR_49.permissions = VAR_21.permissions\n",
"VAR_49.name = VAR_49.name + ' copy'\n",
"self.datamodel.add(VAR_49)\n"
] | [
"@action('copyrole', lazy_gettext('Copy Role'), lazy_gettext(...\n",
"self.update_redirect()\n",
"for item in items:\n",
"new_role = item.__class__()\n",
"return redirect(self.get_redirect())\n",
"new_role.name = item.name\n",
"new_role.permissions = item.permissions\n",
"new_role.name = new_role.name + ' copy'\n",
"self.datamodel.add(new_role)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Expr'",
"For",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_1(self, **VAR_4):...\n",
"return VAR_0\n"
] | [
"def generate_config_section(self, **kwargs):...\n",
"return DEFAULT_CONFIG\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"async def FUNC_76(*VAR_20, **VAR_21):...\n",
"return None\n"
] | [
"async def _insert_client_ip(*args, **kwargs):...\n",
"return None\n"
] | [
0,
0
] | [
"AsyncFunctionDef'",
"Return'"
] |
[
"def FUNC_0(self) ->Dict[str, Any]:...\n",
"VAR_1 = self.an_enum_value.value\n",
"if isinstance(self.a_camel_date_time, datetime):\n",
"VAR_5 = self.a_camel_date_time.isoformat()\n",
"VAR_5 = self.a_camel_date_time.isoformat()\n",
"VAR_2 = self.a_date.isoformat()\n",
"if self.nested_list_of_enums is None:\n",
"VAR_6 = None\n",
"VAR_6 = []\n",
"VAR_3 = self.some_dict\n",
"for nested_list_of_enums_item_data in self.nested_list_of_enums:\n",
"return {'an_enum_value': VAR_1, 'aCamelDateTime': VAR_5, 'a_date': VAR_2,\n 'nested_list_of_enums': VAR_6, 'some_dict': VAR_3}\n",
"VAR_7 = []\n",
"for nested_list_of_enums_item_item_data in nested_list_of_enums_item_data:\n",
"VAR_8 = nested_list_of_enums_item_item_data.value\n",
"VAR_6.append(VAR_7)\n",
"VAR_7.append(VAR_8)\n"
] | [
"def to_dict(self) ->Dict[str, Any]:...\n",
"an_enum_value = self.an_enum_value.value\n",
"if isinstance(self.a_camel_date_time, datetime):\n",
"a_camel_date_time = self.a_camel_date_time.isoformat()\n",
"a_camel_date_time = self.a_camel_date_time.isoformat()\n",
"a_date = self.a_date.isoformat()\n",
"if self.nested_list_of_enums is None:\n",
"nested_list_of_enums = None\n",
"nested_list_of_enums = []\n",
"some_dict = self.some_dict\n",
"for nested_list_of_enums_item_data in self.nested_list_of_enums:\n",
"return {'an_enum_value': an_enum_value, 'aCamelDateTime': a_camel_date_time,\n 'a_date': a_date, 'nested_list_of_enums': nested_list_of_enums,\n 'some_dict': some_dict}\n",
"nested_list_of_enums_item = []\n",
"for nested_list_of_enums_item_item_data in nested_list_of_enums_item_data:\n",
"nested_list_of_enums_item_item = nested_list_of_enums_item_item_data.value\n",
"nested_list_of_enums.append(nested_list_of_enums_item)\n",
"nested_list_of_enums_item.append(nested_list_of_enums_item_item)\n"
] | [
0,
0,
5,
0,
0,
0,
0,
0,
0,
5,
0,
5,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"For",
"Return'",
"Assign'",
"For",
"Assign'",
"Expr'",
"Expr'"
] |
[
"def FUNC_62(VAR_95):...\n",
"VAR_32 = re.compile('^plugin_' + VAR_96 + '(/.*|\\\\..*)?$')\n",
"return [VAR_70 for VAR_70 in VAR_95 if VAR_70 and VAR_32.match(VAR_70)]\n"
] | [
"def filter_plugins(items):...\n",
"regex = re.compile('^plugin_' + plugin + '(/.*|\\\\..*)?$')\n",
"return [item for item in items if item and regex.match(item)]\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"def FUNC_9():...\n",
"yield '<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\\n'\n",
"if VAR_1:\n",
"yield '<?xml-stylesheet type=\"text/xsl\" href=\"/scopelist.xsl\" ?>\\n'\n",
"yield '<objectlist>\\n'\n",
"for line in f:\n",
"VAR_10 = line.strip()\n",
"yield '</objectlist>\\n'\n",
"VAR_13 = str(FUNC_5(VAR_10))\n",
"VAR_25 = FUNC_7(VAR_13)\n",
"print('Error parsing {}. {}. Skip.'.format(VAR_10, str(e)), file=sys.stderr)\n",
"VAR_26 = float(VAR_25['format']['duration'])\n",
"VAR_27 = int(ceil(VAR_26 / VAR_7))\n",
"yield '<count adjust=\"{}\"/>\\n'.format(VAR_27)\n",
"for clip in range(VAR_27):\n",
"yield FUNC_4(VAR_9=clip * stride, VAR_8=span, VAR_10=video) + '\\n'\n"
] | [
"def generate():...\n",
"yield '<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\\n'\n",
"if STYLE:\n",
"yield '<?xml-stylesheet type=\"text/xsl\" href=\"/scopelist.xsl\" ?>\\n'\n",
"yield '<objectlist>\\n'\n",
"for line in f:\n",
"video = line.strip()\n",
"yield '</objectlist>\\n'\n",
"video_path = str(_get_obj_absolute_path(video))\n",
"video_meta = _ffprobe(video_path)\n",
"print('Error parsing {}. {}. Skip.'.format(video, str(e)), file=sys.stderr)\n",
"length_sec = float(video_meta['format']['duration'])\n",
"num_clips = int(ceil(length_sec / stride))\n",
"yield '<count adjust=\"{}\"/>\\n'.format(num_clips)\n",
"for clip in range(num_clips):\n",
"yield _get_object_element(start=clip * stride, span=span, video=video) + '\\n'\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"For",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"For",
"Expr'"
] |
[
"@login_required()...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_157 = []\n",
"VAR_158 = VAR_8.getRoiService()\n",
"VAR_62 = VAR_158.findByImage(VAR_178(VAR_36), None, VAR_8.SERVICE_OPTS)\n",
"for VAR_53 in VAR_62.rois:\n",
"VAR_241 = {}\n",
"VAR_157.sort(VAR_79=lambda x: x['id'])\n",
"VAR_241['id'] = VAR_53.getId().getValue()\n",
"return VAR_157\n",
"VAR_63 = []\n",
"for VAR_3 in VAR_53.copyShapes():\n",
"if VAR_3 is None:\n",
"VAR_63.sort(VAR_79=lambda x: '%03d%03d' % (x.get('theZ', -1), x.get('theT',\n -1)))\n",
"VAR_63.append(shapeMarshal(VAR_3))\n",
"VAR_241['shapes'] = VAR_63\n",
"VAR_157.append(VAR_241)\n"
] | [
"@login_required()...\n",
"\"\"\"docstring\"\"\"\n",
"rois = []\n",
"roiService = conn.getRoiService()\n",
"result = roiService.findByImage(long(imageId), None, conn.SERVICE_OPTS)\n",
"for r in result.rois:\n",
"roi = {}\n",
"rois.sort(key=lambda x: x['id'])\n",
"roi['id'] = r.getId().getValue()\n",
"return rois\n",
"shapes = []\n",
"for s in r.copyShapes():\n",
"if s is None:\n",
"shapes.sort(key=lambda x: '%03d%03d' % (x.get('theZ', -1), x.get('theT', -1)))\n",
"shapes.append(shapeMarshal(s))\n",
"roi['shapes'] = shapes\n",
"rois.append(roi)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"For",
"Assign'",
"Expr'",
"Assign'",
"Return'",
"Assign'",
"For",
"Condition",
"Expr'",
"Expr'",
"Assign'",
"Expr'"
] |
[
"def __init__(self, **VAR_22):...\n",
"\"\"\"docstring\"\"\"\n",
"if 'quote_char' in VAR_22:\n",
"self.use_best_quote_char = False\n",
"for attr in self.options:\n",
"setattr(self, attr, VAR_22.get(attr, getattr(self, attr)))\n",
"self.errors = []\n",
"self.strict = False\n"
] | [
"def __init__(self, **kwargs):...\n",
"\"\"\"docstring\"\"\"\n",
"if 'quote_char' in kwargs:\n",
"self.use_best_quote_char = False\n",
"for attr in self.options:\n",
"setattr(self, attr, kwargs.get(attr, getattr(self, attr)))\n",
"self.errors = []\n",
"self.strict = False\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Assign'",
"For",
"Expr'",
"Assign'",
"Assign'"
] |
[
"def FUNC_14(VAR_3):...\n",
"\"\"\"docstring\"\"\"\n",
"if not VAR_16:\n",
"if VAR_13.get('logging') or False:\n",
"VAR_21.append(FUNC_1(VAR_3))\n",
"print(repr(VAR_3))\n"
] | [
"def log(msg):...\n",
"\"\"\"docstring\"\"\"\n",
"if not request:\n",
"if conf.get('logging') or False:\n",
"debug_log.append(as_unicode(msg))\n",
"print(repr(msg))\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Condition",
"Condition",
"Expr'",
"Expr'"
] |
[
"def FUNC_20(self):...\n",
"VAR_5, VAR_15 = self._test_confirm_start()\n",
"VAR_3 = self.client.post(VAR_15, {'new_password1': 'anewpassword',\n 'new_password2': 'x'})\n",
"self.assertFormError(VAR_3, SetPasswordForm.error_messages['password_mismatch']\n )\n"
] | [
"def test_confirm_different_passwords(self):...\n",
"url, path = self._test_confirm_start()\n",
"response = self.client.post(path, {'new_password1': 'anewpassword',\n 'new_password2': 'x'})\n",
"self.assertFormError(response, SetPasswordForm.error_messages[\n 'password_mismatch'])\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_9(self):...\n",
"self.register_user('id_admin', 'pass', admin=True)\n",
"VAR_8 = self.login('id_admin', 'pass')\n",
"self.register_user('id_nonadmin', 'pass', admin=False)\n",
"VAR_22 = self.login('id_nonadmin', 'pass')\n",
"VAR_23 = self.helper.upload_media(self.upload_resource, self.image_data,\n tok=admin_user_tok)\n",
"VAR_24 = VAR_23['content_uri'][6:]\n",
"VAR_25, VAR_26 = VAR_24.split('/')\n",
"VAR_12, VAR_13 = make_request(self.reactor, FakeSite(self.download_resource\n ), 'GET', VAR_24, shorthand=False, VAR_7=non_admin_user_tok)\n",
"self.assertEqual(200, int(VAR_13.code), msg=channel.result['body'])\n",
"VAR_0 = '/_synapse/admin/v1/media/quarantine/%s/%s' % (urllib.parse.quote(\n VAR_25), urllib.parse.quote(VAR_26))\n",
"VAR_12, VAR_13 = self.make_request('POST', VAR_0, VAR_7=admin_user_tok)\n",
"self.pump(1.0)\n",
"self.assertEqual(200, int(VAR_13.code), msg=channel.result['body'])\n",
"self._ensure_quarantined(VAR_8, VAR_24)\n"
] | [
"def test_quarantine_media_by_id(self):...\n",
"self.register_user('id_admin', 'pass', admin=True)\n",
"admin_user_tok = self.login('id_admin', 'pass')\n",
"self.register_user('id_nonadmin', 'pass', admin=False)\n",
"non_admin_user_tok = self.login('id_nonadmin', 'pass')\n",
"response = self.helper.upload_media(self.upload_resource, self.image_data,\n tok=admin_user_tok)\n",
"server_name_and_media_id = response['content_uri'][6:]\n",
"server_name, media_id = server_name_and_media_id.split('/')\n",
"request, channel = make_request(self.reactor, FakeSite(self.\n download_resource), 'GET', server_name_and_media_id, shorthand=False,\n access_token=non_admin_user_tok)\n",
"self.assertEqual(200, int(channel.code), msg=channel.result['body'])\n",
"url = '/_synapse/admin/v1/media/quarantine/%s/%s' % (urllib.parse.quote(\n server_name), urllib.parse.quote(media_id))\n",
"request, channel = self.make_request('POST', url, access_token=admin_user_tok)\n",
"self.pump(1.0)\n",
"self.assertEqual(200, int(channel.code), msg=channel.result['body'])\n",
"self._ensure_quarantined(admin_user_tok, server_name_and_media_id)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_2(self, VAR_2, VAR_3, VAR_4):...\n",
"self.store = VAR_4.get_datastore()\n",
"self.admin_user = self.register_user('admin', 'pass', admin=True)\n",
"self.admin_user_tok = self.login('admin', 'pass')\n",
"self.other_user = self.register_user('user', 'pass')\n",
"self.other_user_token = self.login('user', 'pass')\n"
] | [
"def prepare(self, reactor, clock, hs):...\n",
"self.store = hs.get_datastore()\n",
"self.admin_user = self.register_user('admin', 'pass', admin=True)\n",
"self.admin_user_tok = self.login('admin', 'pass')\n",
"self.other_user = self.register_user('user', 'pass')\n",
"self.other_user_token = self.login('user', 'pass')\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'"
] |
[
"@VAR_2.route('/shutdown')...\n",
"VAR_32 = VAR_119(request.args.get('parameter').strip())\n",
"VAR_33 = {}\n",
"if VAR_32 in (0, 1):\n",
"calibre_db.dispose()\n",
"if VAR_32 == 2:\n",
"ub.dispose()\n",
"VAR_0.warning('reconnecting to calibre database')\n",
"VAR_33['text'] = _(u'Unknown command')\n",
"if VAR_32 == 0:\n",
"calibre_db.reconnect_db(config, ub.app_DB_path)\n",
"return json.dumps(VAR_33), 400\n",
"VAR_33['text'] = _(u'Server restarted, please reload page')\n",
"VAR_33['text'] = _(u'Performing shutdown of server, please close window')\n",
"VAR_33['text'] = _(u'Reconnect successful')\n",
"web_server.stop(VAR_32 == 0)\n",
"return json.dumps(VAR_33)\n",
"return json.dumps(VAR_33)\n"
] | [
"@admi.route('/shutdown')...\n",
"task = int(request.args.get('parameter').strip())\n",
"showtext = {}\n",
"if task in (0, 1):\n",
"calibre_db.dispose()\n",
"if task == 2:\n",
"ub.dispose()\n",
"log.warning('reconnecting to calibre database')\n",
"showtext['text'] = _(u'Unknown command')\n",
"if task == 0:\n",
"calibre_db.reconnect_db(config, ub.app_DB_path)\n",
"return json.dumps(showtext), 400\n",
"showtext['text'] = _(u'Server restarted, please reload page')\n",
"showtext['text'] = _(u'Performing shutdown of server, please close window')\n",
"showtext['text'] = _(u'Reconnect successful')\n",
"web_server.stop(task == 0)\n",
"return json.dumps(showtext)\n",
"return json.dumps(showtext)\n"
] | [
0,
3,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Assign'",
"Condition",
"Expr'",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Return'",
"Return'"
] |
[
"def FUNC_20(self):...\n",
"VAR_27 = np.array([[1], [2]])\n",
"VAR_32 = os.path.join(test.get_temp_dir(), 'input.npz')\n",
"np.savez(VAR_32, VAR_54=x0)\n",
"VAR_28 = np.ones([2, 10])\n",
"VAR_21 = 'x0=' + VAR_32 + '[a]'\n",
"VAR_22 = 'x0=np.ones([2,10])'\n",
"VAR_31 = saved_model_cli.load_inputs_from_input_arg_string(VAR_21, VAR_22, '')\n",
"self.assertTrue(np.all(VAR_31['x0'] == VAR_28))\n"
] | [
"def testInputParserBothDuplicate(self):...\n",
"x0 = np.array([[1], [2]])\n",
"input_path = os.path.join(test.get_temp_dir(), 'input.npz')\n",
"np.savez(input_path, a=x0)\n",
"x1 = np.ones([2, 10])\n",
"input_str = 'x0=' + input_path + '[a]'\n",
"input_expr_str = 'x0=np.ones([2,10])'\n",
"feed_dict = saved_model_cli.load_inputs_from_input_arg_string(input_str,\n input_expr_str, '')\n",
"self.assertTrue(np.all(feed_dict['x0'] == x1))\n"
] | [
0,
5,
5,
5,
5,
5,
5,
5,
5
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"@staticmethod...\n",
"FUNC_18()\n"
] | [
"@staticmethod...\n",
"_callback()\n"
] | [
0,
0
] | [
"Condition",
"Expr'"
] |
[
"@staticmethod...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_18 = CLASS_4()\n",
"for VAR_11, VAR_5 in VAR_12.items():\n",
"if isinstance(VAR_5, oai.Reference):\n",
"return VAR_18\n",
"VAR_18.errors.append(ParseError(VAR_5=data, detail=\n 'Reference schemas are not supported.'))\n",
"if VAR_5.enum is not None:\n",
"EnumProperty(VAR_11=name, title=data.title or name, VAR_26=True, default=\n data.default, values=EnumProperty.values_from_list(data.enum))\n",
"VAR_28 = CLASS_3.from_data(VAR_5=data, VAR_11=name)\n",
"if isinstance(VAR_28, ParseError):\n",
"VAR_18.errors.append(VAR_28)\n",
"VAR_18.models[VAR_28.reference.class_name] = VAR_28\n"
] | [
"@staticmethod...\n",
"\"\"\"docstring\"\"\"\n",
"result = Schemas()\n",
"for name, data in schemas.items():\n",
"if isinstance(data, oai.Reference):\n",
"return result\n",
"result.errors.append(ParseError(data=data, detail=\n 'Reference schemas are not supported.'))\n",
"if data.enum is not None:\n",
"EnumProperty(name=name, title=data.title or name, required=True, default=\n data.default, values=EnumProperty.values_from_list(data.enum))\n",
"s = Model.from_data(data=data, name=name)\n",
"if isinstance(s, ParseError):\n",
"result.errors.append(s)\n",
"result.models[s.reference.class_name] = s\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"For",
"Condition",
"Return'",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Expr'",
"Assign'"
] |
[
"def FUNC_12(self):...\n",
"p('Exported terms:')\n",
"for VAR_19 in findAll('[data-export]', self):\n",
"for term in config.linkTextsFromElement(VAR_19):\n",
"p('Unexported terms:')\n",
"p(' ' + term)\n",
"for VAR_19 in findAll('[data-noexport]', self):\n",
"for term in config.linkTextsFromElement(VAR_19):\n",
"p(' ' + term)\n"
] | [
"def printTargets(self):...\n",
"p('Exported terms:')\n",
"for el in findAll('[data-export]', self):\n",
"for term in config.linkTextsFromElement(el):\n",
"p('Unexported terms:')\n",
"p(' ' + term)\n",
"for el in findAll('[data-noexport]', self):\n",
"for term in config.linkTextsFromElement(el):\n",
"p(' ' + term)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"For",
"For",
"Expr'",
"Expr'",
"For",
"For",
"Expr'"
] |
[
"def FUNC_17(self):...\n",
"VAR_27 = np.ones([2, 10])\n",
"VAR_38 = np.array([[1], [2], [3]])\n",
"VAR_39 = np.mgrid[0:5, 0:5]\n",
"VAR_40 = [[3], [4]]\n",
"VAR_21 = (\n 'x1=np.ones([2,10]);x2=np.array([[1],[2],[3]]);x3=np.mgrid[0:5,0:5];x4=[[3],[4]]'\n )\n",
"VAR_30 = saved_model_cli.load_inputs_from_input_arg_string('', VAR_21, '')\n",
"self.assertTrue(np.all(VAR_30['x1'] == VAR_27))\n",
"self.assertTrue(np.all(VAR_30['x2'] == VAR_38))\n",
"self.assertTrue(np.all(VAR_30['x3'] == VAR_39))\n",
"self.assertTrue(np.all(VAR_30['x4'] == VAR_40))\n"
] | [
"def testInputParserPythonExpression(self):...\n",
"x1 = np.ones([2, 10])\n",
"x2 = np.array([[1], [2], [3]])\n",
"x3 = np.mgrid[0:5, 0:5]\n",
"x4 = [[3], [4]]\n",
"input_expr_str = (\n 'x1=np.ones([2,10]);x2=np.array([[1],[2],[3]]);x3=np.mgrid[0:5,0:5];x4=[[3],[4]]'\n )\n",
"feed_dict = saved_model_cli.load_inputs_from_input_arg_string('',\n input_expr_str, '')\n",
"self.assertTrue(np.all(feed_dict['x1'] == x1))\n",
"self.assertTrue(np.all(feed_dict['x2'] == x2))\n",
"self.assertTrue(np.all(feed_dict['x3'] == x3))\n",
"self.assertTrue(np.all(feed_dict['x4'] == x4))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_98(self, VAR_10):...\n",
"\"\"\"docstring\"\"\"\n",
"self.json_procedures[VAR_10.__name__] = VAR_10\n",
"return VAR_10\n"
] | [
"def json(self, f):...\n",
"\"\"\"docstring\"\"\"\n",
"self.json_procedures[f.__name__] = f\n",
"return f\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Return'"
] |
[
"def FUNC_2(self, VAR_1, VAR_2=None):...\n",
""
] | [
"def get(self, arg, word=None):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_13(VAR_13, VAR_14, VAR_15, VAR_16=None):...\n",
""
] | [
"def create_and_login_user(org, name, email, picture=None):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_3(self, *, VAR_4: str) ->Set[str]:...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_8 = super().get_imports(VAR_4=prefix)\n",
"VAR_8.add('from typing import Dict')\n",
"if self.default is not None:\n",
"VAR_8.add('from dataclasses import field')\n",
"return VAR_8\n",
"VAR_8.add('from typing import cast')\n"
] | [
"def get_imports(self, *, prefix: str) ->Set[str]:...\n",
"\"\"\"docstring\"\"\"\n",
"imports = super().get_imports(prefix=prefix)\n",
"imports.add('from typing import Dict')\n",
"if self.default is not None:\n",
"imports.add('from dataclasses import field')\n",
"return imports\n",
"imports.add('from typing import cast')\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Expr'",
"Condition",
"Expr'",
"Return'",
"Expr'"
] |
[
"def FUNC_118(*VAR_11, **VAR_351):...\n",
""
] | [
"def f(*args, **kwargs):...\n",
""
] | [
0,
0
] | [
"FunctionDef'",
"Condition"
] |
[
"def FUNC_12(VAR_23, VAR_24, VAR_27, VAR_28=None, VAR_29=1):...\n",
"if 'mandatory' in VAR_27:\n",
"for mandatory in VAR_27['mandatory']:\n",
"if VAR_28 is None:\n",
"if mandatory not in VAR_28:\n",
"VAR_28 = {}\n",
"VAR_10 = dict(VAR_28)\n",
"return None\n",
"if 'suffix' not in VAR_10 and VAR_29 > 1:\n",
"VAR_10['suffix'] = '_%d' % VAR_29\n",
"if 'div' in VAR_10:\n",
"VAR_10['_div'] = VAR_10['div']\n",
"if 'div' in VAR_27:\n",
"if VAR_10.get('template'):\n",
"VAR_10['_div'] = VAR_27['div'](VAR_23)\n",
"VAR_10['template'] = VAR_24.template_folder_key + '/' + VAR_10['template']\n",
"VAR_10['template'] = VAR_24.template_folder_key + '/' + VAR_27['template'](\n VAR_23)\n",
"if 'suffix' in VAR_10:\n",
"if VAR_10.get('template_header'):\n",
"VAR_10['_div'] = VAR_10['_div'] + VAR_10['suffix']\n",
"if not VAR_5.match(VAR_10['_div']):\n",
"VAR_10['template_header'] = VAR_24.template_folder_key + '/' + VAR_10[\n 'template_header']\n",
"if 'name' not in VAR_10:\n",
"VAR_0.warning(\n 'Template config {} contains invalid div identifier {}, skipping it'.\n format(VAR_23, VAR_10['_div']))\n",
"VAR_10['name'] = VAR_24._plugin_name\n",
"if 'custom_bindings' not in VAR_10 or VAR_10['custom_bindings']:\n",
"return None\n",
"VAR_123 = 'allowBindings: true'\n",
"VAR_10['_key'] = 'plugin_' + VAR_23\n",
"if 'data_bind' in VAR_10:\n",
"if 'suffix' in VAR_10:\n",
"VAR_123 = VAR_123 + ', ' + VAR_10['data_bind']\n",
"VAR_123 = VAR_123.replace('\"', '\\\\\"')\n",
"VAR_10['_key'] += VAR_10['suffix']\n",
"VAR_10['_plugin'] = VAR_23\n",
"VAR_10['data_bind'] = VAR_123\n",
"return VAR_10\n"
] | [
"def _process_template_config(name, implementation, rule, config=None, counter=1...\n",
"if 'mandatory' in rule:\n",
"for mandatory in rule['mandatory']:\n",
"if config is None:\n",
"if mandatory not in config:\n",
"config = {}\n",
"data = dict(config)\n",
"return None\n",
"if 'suffix' not in data and counter > 1:\n",
"data['suffix'] = '_%d' % counter\n",
"if 'div' in data:\n",
"data['_div'] = data['div']\n",
"if 'div' in rule:\n",
"if data.get('template'):\n",
"data['_div'] = rule['div'](name)\n",
"data['template'] = implementation.template_folder_key + '/' + data['template']\n",
"data['template'] = implementation.template_folder_key + '/' + rule['template'](\n name)\n",
"if 'suffix' in data:\n",
"if data.get('template_header'):\n",
"data['_div'] = data['_div'] + data['suffix']\n",
"if not _valid_div_re.match(data['_div']):\n",
"data['template_header'] = implementation.template_folder_key + '/' + data[\n 'template_header']\n",
"if 'name' not in data:\n",
"_logger.warning(\n 'Template config {} contains invalid div identifier {}, skipping it'.\n format(name, data['_div']))\n",
"data['name'] = implementation._plugin_name\n",
"if 'custom_bindings' not in data or data['custom_bindings']:\n",
"return None\n",
"data_bind = 'allowBindings: true'\n",
"data['_key'] = 'plugin_' + name\n",
"if 'data_bind' in data:\n",
"if 'suffix' in data:\n",
"data_bind = data_bind + ', ' + data['data_bind']\n",
"data_bind = data_bind.replace('\"', '\\\\\"')\n",
"data['_key'] += data['suffix']\n",
"data['_plugin'] = name\n",
"data['data_bind'] = data_bind\n",
"return data\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,
0
] | [
"FunctionDef'",
"Condition",
"For",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Return'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Return'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"AugAssign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_27(self):...\n",
"for test_str in ('Iñtërnâtiônàlizætiøn', \"1234'\", -1234):\n",
"VAR_21 = self.client.post('%s/admin_widgets/event/add/' % self.admin_root,\n {'main_band': test_str})\n",
"self.assertContains(VAR_21,\n 'Select a valid choice. That choice is not one of the available choices.')\n"
] | [
"def test_invalid_target_id(self):...\n",
"for test_str in ('Iñtërnâtiônàlizætiøn', \"1234'\", -1234):\n",
"response = self.client.post('%s/admin_widgets/event/add/' % self.admin_root,\n {'main_band': test_str})\n",
"self.assertContains(response,\n 'Select a valid choice. That choice is not one of the available choices.')\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"For",
"Assign'",
"Expr'"
] |
[
"def FUNC_9(self):...\n",
"return '-'.join(p.replace('-', '_-') for p in self.namespace.split('/'))\n"
] | [
"def get_build_slug(self):...\n",
"return '-'.join(p.replace('-', '_-') for p in self.namespace.split('/'))\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"from django.contrib.auth.decorators import login_required\n",
"from django.shortcuts import render, redirect, get_object_or_404\n",
"from ...core.utils.views import is_post, post_data\n",
"from ..models import Comment\n",
"from .forms import FlagForm\n",
"@login_required...\n",
"VAR_2 = get_object_or_404(Comment, pk=comment_id)\n",
"VAR_3 = FlagForm(user=request.user, VAR_2=comment, data=post_data(request))\n",
"if is_post(VAR_0) and VAR_3.is_valid():\n",
"VAR_3.save()\n",
"return render(VAR_0=request, template_name=\n 'spirit/comment/flag/create.html', context={'form': form, 'comment':\n comment})\n",
"return redirect(VAR_0.POST.get('next', VAR_2.get_absolute_url()))\n"
] | [
"from django.contrib.auth.decorators import login_required\n",
"from django.shortcuts import render, redirect, get_object_or_404\n",
"from ...core.utils.views import is_post, post_data\n",
"from ..models import Comment\n",
"from .forms import FlagForm\n",
"@login_required...\n",
"comment = get_object_or_404(Comment, pk=comment_id)\n",
"form = FlagForm(user=request.user, comment=comment, data=post_data(request))\n",
"if is_post(request) and form.is_valid():\n",
"form.save()\n",
"return render(request=request, template_name=\n 'spirit/comment/flag/create.html', context={'form': form, 'comment':\n comment})\n",
"return redirect(request.POST.get('next', comment.get_absolute_url()))\n"
] | [
0,
0,
4,
0,
0,
0,
0,
0,
0,
0,
0,
4
] | [
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"ImportFrom'",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Return'",
"Return'"
] |
[
"def FUNC_30(VAR_16):...\n",
"VAR_35 = PerspectivesKeyFetcher(self.hs)\n",
"VAR_23 = {VAR_34: {'key1': 0}}\n",
"self.expect_outgoing_key_query(VAR_34, 'key1', VAR_16)\n",
"return self.get_success(VAR_35.get_keys(VAR_23))\n"
] | [
"def get_key_from_perspectives(response):...\n",
"fetcher = PerspectivesKeyFetcher(self.hs)\n",
"keys_to_fetch = {SERVER_NAME: {'key1': 0}}\n",
"self.expect_outgoing_key_query(SERVER_NAME, 'key1', response)\n",
"return self.get_success(fetcher.get_keys(keys_to_fetch))\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Return'"
] |
[
"def FUNC_14(self, VAR_6):...\n",
"if not self.query:\n",
"frappe.throw(_('Must specify a Query to run'), title=_('Report Document Error')\n )\n",
"if not self.query.lower().startswith('select'):\n",
"frappe.throw(_('Query must be a SELECT'), title=_('Report Document Error'))\n",
"VAR_15 = [list(t) for t in frappe.db.sql(self.query, VAR_6, debug=True)]\n",
"VAR_13 = self.get_columns() or [cstr(c[0]) for c in frappe.db.get_description()\n ]\n",
"return [VAR_13, VAR_15]\n"
] | [
"def execute_query_report(self, filters):...\n",
"if not self.query:\n",
"frappe.throw(_('Must specify a Query to run'), title=_('Report Document Error')\n )\n",
"if not self.query.lower().startswith('select'):\n",
"frappe.throw(_('Query must be a SELECT'), title=_('Report Document Error'))\n",
"result = [list(t) for t in frappe.db.sql(self.query, filters, debug=True)]\n",
"columns = self.get_columns() or [cstr(c[0]) for c in frappe.db.\n get_description()]\n",
"return [columns, result]\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_15(VAR_3, **VAR_4):...\n",
"VAR_2.update(VAR_4)\n",
"return 200, VAR_4\n"
] | [
"def _callback(request, **kwargs):...\n",
"got_kwargs.update(kwargs)\n",
"return 200, kwargs\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Return'"
] |
[
"def FUNC_7(self):...\n",
"return logging.INFO\n"
] | [
"def _log_level_default(self):...\n",
"return logging.INFO\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"def FUNC_53(self):...\n",
"frappe.clear_document_cache(self.doctype, self.name)\n"
] | [
"def clear_cache(self):...\n",
"frappe.clear_document_cache(self.doctype, self.name)\n"
] | [
0,
0
] | [
"FunctionDef'",
"Expr'"
] |
[
"def FUNC_43(self, VAR_21, VAR_22, VAR_20):...\n",
"if 'view' in VAR_92:\n",
"if not VAR_92['view'].get(VAR_21):\n",
"return None\n",
"VAR_92['view'][VAR_21] = dict()\n",
"VAR_92['view'][VAR_21][VAR_22] = VAR_20\n"
] | [
"def set_view_property(self, page, prop, value):...\n",
"if 'view' in flask_session:\n",
"if not flask_session['view'].get(page):\n",
"return None\n",
"flask_session['view'][page] = dict()\n",
"flask_session['view'][page][prop] = value\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Condition",
"Return'",
"Assign'",
"Assign'"
] |
[
"def FUNC_3(self):...\n",
"self.transitiveDependencies.clear()\n",
"self.assembleDocument()\n",
"self.processDocument()\n"
] | [
"def preprocess(self):...\n",
"self.transitiveDependencies.clear()\n",
"self.assembleDocument()\n",
"self.processDocument()\n"
] | [
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_20(self, VAR_6, VAR_7, VAR_8):...\n",
"VAR_12 = json.loads(self.json)\n",
"VAR_13 = self.get_standard_report_columns(VAR_12)\n",
"VAR_15 = []\n",
"VAR_26, VAR_27, VAR_14 = self.get_standard_report_order_by(VAR_12)\n",
"VAR_28 = frappe.get_list(self.ref_doctype, fields=[(get_group_by_field(\n group_by_args, c[1]) if c[0] == '_aggregate_column' and group_by_args else\n Report._format([c[1], c[0]])) for c in columns], VAR_6=self.\n get_standard_report_filters(params, filters), VAR_26=order_by, VAR_27=\n group_by, as_list=True, VAR_7=limit, VAR_8=user)\n",
"VAR_13 = self.build_standard_report_columns(VAR_13, VAR_14)\n",
"VAR_15 = VAR_15 + [list(d) for d in VAR_28]\n",
"if VAR_12.get('add_totals_row'):\n",
"VAR_15 = append_totals_row(VAR_15)\n",
"return VAR_13, VAR_15\n"
] | [
"def run_standard_report(self, filters, limit, user):...\n",
"params = json.loads(self.json)\n",
"columns = self.get_standard_report_columns(params)\n",
"result = []\n",
"order_by, group_by, group_by_args = self.get_standard_report_order_by(params)\n",
"_result = frappe.get_list(self.ref_doctype, fields=[(get_group_by_field(\n group_by_args, c[1]) if c[0] == '_aggregate_column' and group_by_args else\n Report._format([c[1], c[0]])) for c in columns], filters=self.\n get_standard_report_filters(params, filters), order_by=order_by,\n group_by=group_by, as_list=True, limit=limit, user=user)\n",
"columns = self.build_standard_report_columns(columns, group_by_args)\n",
"result = result + [list(d) for d in _result]\n",
"if params.get('add_totals_row'):\n",
"result = append_totals_row(result)\n",
"return columns, result\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Return'"
] |
[
"@log_function...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_2 = FUNC_1('/groups/%s/users/%s/accept_invite', VAR_30, VAR_16)\n",
"return self.client.post_json(VAR_5=destination, VAR_2=path, VAR_39=content,\n VAR_15=True)\n"
] | [
"@log_function...\n",
"\"\"\"docstring\"\"\"\n",
"path = _create_v1_path('/groups/%s/users/%s/accept_invite', group_id, user_id)\n",
"return self.client.post_json(destination=destination, path=path, data=\n content, ignore_backoff=True)\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Return'"
] |
[
"def FUNC_31(self):...\n",
"VAR_5 = self._makeContext()\n",
"VAR_5.evaluate('context/__class__')\n",
"VAR_5.evaluate('nocall: random/_itertools/repeat')\n",
"VAR_5.evaluate('random/_itertools/repeat/foobar')\n"
] | [
"def test_underscore_traversal(self):...\n",
"ec = self._makeContext()\n",
"ec.evaluate('context/__class__')\n",
"ec.evaluate('nocall: random/_itertools/repeat')\n",
"ec.evaluate('random/_itertools/repeat/foobar')\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_104():...\n",
"from frappe.core.doctype.domain_settings.domain_settings import get_active_domains\n",
"return FUNC_104()\n"
] | [
"def get_active_domains():...\n",
"from frappe.core.doctype.domain_settings.domain_settings import get_active_domains\n",
"return get_active_domains()\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"ImportFrom'",
"Return'"
] |
[
"def FUNC_33(self):...\n",
"self.parser = saved_model_cli.create_parser()\n",
"VAR_9 = test.test_src_dir_path(VAR_0)\n",
"VAR_44 = np.array([[1], [2]])\n",
"VAR_45 = np.zeros((6, 3))\n",
"VAR_31 = os.path.join(test.get_temp_dir(), 'testRunCommandNewOutdir_inputs.npz'\n )\n",
"VAR_41 = os.path.join(test.get_temp_dir(), 'new_dir')\n",
"if os.path.isdir(VAR_41):\n",
"shutil.rmtree(VAR_41)\n",
"np.savez(VAR_31, VAR_26=x, VAR_27=x_notused)\n",
"VAR_10 = self.parser.parse_args(['run', '--dir', VAR_9, '--tag_set',\n 'serve', '--signature_def', 'serving_default', '--inputs', 'x=' +\n VAR_31 + '[x0]', '--outdir', VAR_41, '--tf_debug'])\n",
"def FUNC_38(VAR_47):...\n",
"return VAR_47\n"
] | [
"def testRunCommandWithDebuggerEnabled(self):...\n",
"self.parser = saved_model_cli.create_parser()\n",
"base_path = test.test_src_dir_path(SAVED_MODEL_PATH)\n",
"x = np.array([[1], [2]])\n",
"x_notused = np.zeros((6, 3))\n",
"input_path = os.path.join(test.get_temp_dir(),\n 'testRunCommandNewOutdir_inputs.npz')\n",
"output_dir = os.path.join(test.get_temp_dir(), 'new_dir')\n",
"if os.path.isdir(output_dir):\n",
"shutil.rmtree(output_dir)\n",
"np.savez(input_path, x0=x, x1=x_notused)\n",
"args = self.parser.parse_args(['run', '--dir', base_path, '--tag_set',\n 'serve', '--signature_def', 'serving_default', '--inputs', 'x=' +\n input_path + '[x0]', '--outdir', output_dir, '--tf_debug'])\n",
"def fake_wrapper_session(sess):...\n",
"return sess\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Expr'",
"Assign'",
"FunctionDef'",
"Return'"
] |
[
"def FUNC_105(VAR_62, VAR_9, VAR_166=None, VAR_167=False, VAR_168=True):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_202 = FUNC_48(VAR_62)\n",
"if VAR_202.track_changes:\n",
"VAR_216 = VAR_12.get_all('Version', VAR_106={'ref_doctype': doctype,\n 'docname': name, 'order_by': 'creation' if head else None, 'limit':\n limit}, VAR_34=1)\n",
"if VAR_168:\n",
"from frappe.chat.util import squashify, dictify, safe_json_loads\n",
"VAR_217 = []\n",
"for VAR_9 in VAR_216:\n",
"VAR_9 = squashify(VAR_9)\n",
"return VAR_217\n",
"VAR_94 = FUNC_45('Version', VAR_9)\n",
"VAR_224 = VAR_94.data\n",
"VAR_224 = safe_json_loads(VAR_224)\n",
"VAR_224 = dictify(dict(version=data, VAR_10=doc.owner, creation=doc.creation))\n",
"VAR_217.append(VAR_224)\n"
] | [
"def get_version(doctype, name, limit=None, head=False, raise_err=True):...\n",
"\"\"\"docstring\"\"\"\n",
"meta = get_meta(doctype)\n",
"if meta.track_changes:\n",
"names = db.get_all('Version', filters={'ref_doctype': doctype, 'docname':\n name, 'order_by': 'creation' if head else None, 'limit': limit}, as_list=1)\n",
"if raise_err:\n",
"from frappe.chat.util import squashify, dictify, safe_json_loads\n",
"versions = []\n",
"for name in names:\n",
"name = squashify(name)\n",
"return versions\n",
"doc = get_doc('Version', name)\n",
"data = doc.data\n",
"data = safe_json_loads(data)\n",
"data = dictify(dict(version=data, user=doc.owner, creation=doc.creation))\n",
"versions.append(data)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Condition",
"ImportFrom'",
"Assign'",
"For",
"Assign'",
"Return'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"@ensure_csrf_cookie...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_10 = SlashSeparatedCourseKey.from_deprecated_string(VAR_10)\n",
"VAR_131 = 'bulk_course_email'\n",
"VAR_133 = instructor_task.api.get_instructor_task_history(VAR_10, VAR_131=\n task_type)\n",
"VAR_63 = {'emails': map(extract_email_features, VAR_133)}\n",
"return JsonResponse(VAR_63)\n"
] | [
"@ensure_csrf_cookie...\n",
"\"\"\"docstring\"\"\"\n",
"course_id = SlashSeparatedCourseKey.from_deprecated_string(course_id)\n",
"task_type = 'bulk_course_email'\n",
"emails = instructor_task.api.get_instructor_task_history(course_id,\n task_type=task_type)\n",
"response_payload = {'emails': map(extract_email_features, emails)}\n",
"return JsonResponse(response_payload)\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Return'"
] |
[
"def FUNC_6(self):...\n",
"return self.kw_project\n"
] | [
"def get_kwargs(self):...\n",
"return self.kw_project\n"
] | [
0,
0
] | [
"FunctionDef'",
"Return'"
] |
[
"@wraps(VAR_28)...\n",
"VAR_1.debug('jsonp')\n",
"VAR_19 = VAR_9.get('server_id', None)\n",
"VAR_315 = 500\n",
"if VAR_19 is None and VAR_2.session.get('connector'):\n",
"if isinstance(ex, omero.SecurityViolation):\n",
"VAR_19 = VAR_2.session['connector'].server_id\n",
"VAR_9['server_id'] = VAR_19\n",
"VAR_315 = 403\n",
"if isinstance(ex, omero.ApiUsageException):\n",
"VAR_54 = VAR_28(VAR_2, *VAR_116, **kwargs)\n",
"VAR_316 = traceback.format_exc()\n",
"VAR_315 = 400\n",
"if VAR_9.get('_raw', False):\n",
"VAR_1.debug(VAR_316)\n",
"return VAR_54\n",
"if isinstance(VAR_54, HttpResponse):\n",
"if VAR_9.get('_raw', False) or VAR_9.get('_internal', False):\n",
"return VAR_54\n",
"VAR_203 = VAR_2.GET.get('callback', None)\n",
"return JsonResponse({'message': str(ex), 'stacktrace': VAR_316}, VAR_315=status\n )\n",
"if VAR_203 is not None and not VAR_9.get('_internal', False):\n",
"VAR_54 = json.dumps(VAR_54)\n",
"if VAR_9.get('_internal', False):\n",
"VAR_54 = '%s(%s)' % (VAR_203, VAR_54)\n",
"return VAR_54\n",
"VAR_281 = type(VAR_54) is dict\n",
"return HttpJavascriptResponse(VAR_54)\n",
"return JsonResponse(VAR_54, VAR_281=safe)\n"
] | [
"@wraps(f)...\n",
"logger.debug('jsonp')\n",
"server_id = kwargs.get('server_id', None)\n",
"status = 500\n",
"if server_id is None and request.session.get('connector'):\n",
"if isinstance(ex, omero.SecurityViolation):\n",
"server_id = request.session['connector'].server_id\n",
"kwargs['server_id'] = server_id\n",
"status = 403\n",
"if isinstance(ex, omero.ApiUsageException):\n",
"rv = f(request, *args, **kwargs)\n",
"trace = traceback.format_exc()\n",
"status = 400\n",
"if kwargs.get('_raw', False):\n",
"logger.debug(trace)\n",
"return rv\n",
"if isinstance(rv, HttpResponse):\n",
"if kwargs.get('_raw', False) or kwargs.get('_internal', False):\n",
"return rv\n",
"c = request.GET.get('callback', None)\n",
"return JsonResponse({'message': str(ex), 'stacktrace': trace}, status=status)\n",
"if c is not None and not kwargs.get('_internal', False):\n",
"rv = json.dumps(rv)\n",
"if kwargs.get('_internal', False):\n",
"rv = '%s(%s)' % (c, rv)\n",
"return rv\n",
"safe = type(rv) is dict\n",
"return HttpJavascriptResponse(rv)\n",
"return JsonResponse(rv, safe=safe)\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
] | [
"Condition",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Return'",
"Condition",
"Condition",
"Return'",
"Assign'",
"Return'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Assign'",
"Return'",
"Return'"
] |
[
"def FUNC_0(self, VAR_1, VAR_2):...\n",
"VAR_3 = self.setup_test_homeserver(resource_for_federation=Mock(),\n http_client=None)\n",
"return VAR_3\n"
] | [
"def make_homeserver(self, reactor, clock):...\n",
"hs = self.setup_test_homeserver(resource_for_federation=Mock(), http_client\n =None)\n",
"return hs\n"
] | [
0,
4,
0
] | [
"FunctionDef'",
"Assign'",
"Return'"
] |
[
"@FUNC_0...\n",
"if self.config.worker_app:\n",
"return GroupsLocalWorkerHandler(self)\n",
"return GroupsLocalHandler(self)\n"
] | [
"@cache_in_self...\n",
"if self.config.worker_app:\n",
"return GroupsLocalWorkerHandler(self)\n",
"return GroupsLocalHandler(self)\n"
] | [
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Return'"
] |
[
"def __init__(self, *VAR_17, **VAR_18):...\n",
"super().__init__(*VAR_17, **kwargs)\n",
"self.url, VAR_10 = self.spec.split('/', 1)\n",
"self.repo = urllib.parse.unquote(self.url)\n",
"self.unresolved_ref = urllib.parse.unquote(VAR_10)\n",
"if not self.unresolved_ref:\n"
] | [
"def __init__(self, *args, **kwargs):...\n",
"super().__init__(*args, **kwargs)\n",
"self.url, unresolved_ref = self.spec.split('/', 1)\n",
"self.repo = urllib.parse.unquote(self.url)\n",
"self.unresolved_ref = urllib.parse.unquote(unresolved_ref)\n",
"if not self.unresolved_ref:\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Expr'",
"Assign'",
"Assign'",
"Assign'",
"Condition"
] |
[
"def FUNC_52(self):...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_69 = self.get_doc_before_save()\n",
"if self._action == 'save':\n",
"self.run_method('on_update')\n",
"if self._action == 'submit':\n",
"self.clear_cache()\n",
"self.run_method('on_update')\n",
"if self._action == 'cancel':\n",
"self.notify_update()\n",
"self.run_method('on_submit')\n",
"self.run_method('on_cancel')\n",
"if self._action == 'update_after_submit':\n",
"update_global_search(self)\n",
"self.check_no_back_links_exist()\n",
"self.run_method('on_update_after_submit')\n",
"self.save_version()\n",
"self.run_method('on_change')\n",
"if (self.doctype, self.name) in frappe.flags.currently_saving:\n",
"frappe.flags.currently_saving.remove((self.doctype, self.name))\n",
"self.latest = None\n"
] | [
"def run_post_save_methods(self):...\n",
"\"\"\"docstring\"\"\"\n",
"doc_before_save = self.get_doc_before_save()\n",
"if self._action == 'save':\n",
"self.run_method('on_update')\n",
"if self._action == 'submit':\n",
"self.clear_cache()\n",
"self.run_method('on_update')\n",
"if self._action == 'cancel':\n",
"self.notify_update()\n",
"self.run_method('on_submit')\n",
"self.run_method('on_cancel')\n",
"if self._action == 'update_after_submit':\n",
"update_global_search(self)\n",
"self.check_no_back_links_exist()\n",
"self.run_method('on_update_after_submit')\n",
"self.save_version()\n",
"self.run_method('on_change')\n",
"if (self.doctype, self.name) in frappe.flags.currently_saving:\n",
"frappe.flags.currently_saving.remove((self.doctype, self.name))\n",
"self.latest = None\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Condition",
"Expr'",
"Assign'"
] |
[
"@FUNC_0...\n",
"return DeactivateAccountHandler(self)\n"
] | [
"@cache_in_self...\n",
"return DeactivateAccountHandler(self)\n"
] | [
0,
0
] | [
"Condition",
"Return'"
] |
[
"def FUNC_12(VAR_14: Union[Text, Path], VAR_4: Any) ->None:...\n",
"\"\"\"docstring\"\"\"\n",
"import jsonpickle.ext.numpy as jsonpickle_numpy\n",
"import jsonpickle\n",
"jsonpickle_numpy.register_handlers()\n",
"rasa.shared.utils.io.write_text_file(jsonpickle.dumps(VAR_4), VAR_14)\n"
] | [
"def json_pickle(file_name: Union[Text, Path], obj: Any) ->None:...\n",
"\"\"\"docstring\"\"\"\n",
"import jsonpickle.ext.numpy as jsonpickle_numpy\n",
"import jsonpickle\n",
"jsonpickle_numpy.register_handlers()\n",
"rasa.shared.utils.io.write_text_file(jsonpickle.dumps(obj), file_name)\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Import'",
"Import'",
"Expr'",
"Expr'"
] |
[
"def FUNC_76(self):...\n",
"VAR_90 = self.token['align']\n",
"VAR_91 = len(VAR_90)\n",
"VAR_92 = self.renderer.placeholder()\n",
"VAR_69 = self.renderer.placeholder()\n",
"for VAR_101, value in enumerate(self.token['header']):\n",
"VAR_81 = VAR_90[VAR_101] if VAR_101 < VAR_91 else None\n",
"VAR_69 += self.renderer.table_row(VAR_92)\n",
"VAR_71 = {'header': True, 'align': VAR_81}\n",
"VAR_67 = self.renderer.placeholder()\n",
"VAR_92 += self.renderer.table_cell(self.inline(value), **flags)\n",
"for VAR_101, row in enumerate(self.token['cells']):\n",
"VAR_92 = self.renderer.placeholder()\n",
"return self.renderer.table(VAR_69, VAR_67)\n",
"for j, value in enumerate(row):\n",
"VAR_81 = VAR_90[j] if j < VAR_91 else None\n",
"VAR_67 += self.renderer.table_row(VAR_92)\n",
"VAR_71 = {'header': False, 'align': VAR_81}\n",
"VAR_92 += self.renderer.table_cell(self.inline(value), **flags)\n"
] | [
"def output_table(self):...\n",
"aligns = self.token['align']\n",
"aligns_length = len(aligns)\n",
"cell = self.renderer.placeholder()\n",
"header = self.renderer.placeholder()\n",
"for i, value in enumerate(self.token['header']):\n",
"align = aligns[i] if i < aligns_length else None\n",
"header += self.renderer.table_row(cell)\n",
"flags = {'header': True, 'align': align}\n",
"body = self.renderer.placeholder()\n",
"cell += self.renderer.table_cell(self.inline(value), **flags)\n",
"for i, row in enumerate(self.token['cells']):\n",
"cell = self.renderer.placeholder()\n",
"return self.renderer.table(header, body)\n",
"for j, value in enumerate(row):\n",
"align = aligns[j] if j < aligns_length else None\n",
"body += self.renderer.table_row(cell)\n",
"flags = {'header': False, 'align': align}\n",
"cell += self.renderer.table_cell(self.inline(value), **flags)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Assign'",
"AugAssign'",
"Assign'",
"Assign'",
"AugAssign'",
"For",
"Assign'",
"Return'",
"For",
"Assign'",
"AugAssign'",
"Assign'",
"AugAssign'"
] |
[
"def FUNC_2(self, VAR_1):...\n",
"from openapi_python_client.parser.properties import FileProperty\n",
"VAR_5 = VAR_1.MagicMock()\n",
"VAR_1.patch('openapi_python_client.utils.snake_case')\n",
"VAR_9 = 'blah'\n",
"VAR_4 = VAR_38(VAR_5=name, VAR_26=True, default=None)\n",
"assert VAR_4.get_imports(VAR_9=prefix) == {f'from {VAR_9}.types import File',\n 'from dataclasses import astuple'}\n",
"VAR_4.required = False\n",
"assert VAR_4.get_imports(VAR_9=prefix) == {'from typing import Optional',\n f'from {VAR_9}.types import File', 'from dataclasses import astuple'}\n"
] | [
"def test_get_imports(self, mocker):...\n",
"from openapi_python_client.parser.properties import FileProperty\n",
"name = mocker.MagicMock()\n",
"mocker.patch('openapi_python_client.utils.snake_case')\n",
"prefix = 'blah'\n",
"p = FileProperty(name=name, required=True, default=None)\n",
"assert p.get_imports(prefix=prefix) == {f'from {prefix}.types import File',\n 'from dataclasses import astuple'}\n",
"p.required = False\n",
"assert p.get_imports(prefix=prefix) == {'from typing import Optional',\n f'from {prefix}.types import File', 'from dataclasses import astuple'}\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"ImportFrom'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Assert'",
"Assign'",
"Assert'"
] |
[
"@require_POST...\n",
"VAR_3 = get_object_or_404(Topic.objects.for_access(VAR_0.user), VAR_2=topic_id)\n",
"VAR_4 = NotificationCreationForm(user=request.user, VAR_3=topic, data=\n request.POST)\n",
"if VAR_4.is_valid():\n",
"VAR_4.save()\n",
"messages.error(VAR_0, utils.render_form_errors(VAR_4))\n",
"return redirect(VAR_0.POST.get('next', VAR_3.get_absolute_url()))\n"
] | [
"@require_POST...\n",
"topic = get_object_or_404(Topic.objects.for_access(request.user), pk=topic_id)\n",
"form = NotificationCreationForm(user=request.user, topic=topic, data=\n request.POST)\n",
"if form.is_valid():\n",
"form.save()\n",
"messages.error(request, utils.render_form_errors(form))\n",
"return redirect(request.POST.get('next', topic.get_absolute_url()))\n"
] | [
0,
0,
0,
0,
0,
0,
4
] | [
"Condition",
"Assign'",
"Assign'",
"Condition",
"Expr'",
"Expr'",
"Return'"
] |
[
"def FUNC_4(self):...\n",
"VAR_4 = self._makeEngine()\n",
"for p in ('x', 'x/y', 'x/y/z'):\n",
"VAR_4.compile(p)\n",
"VAR_4.compile('path:a|b|c/d/e')\n",
"VAR_4.compile('string:Fred')\n",
"VAR_4.compile('string:A$B')\n",
"VAR_4.compile('string:a ${x/y} b ${y/z} c')\n",
"VAR_4.compile('python: 2 + 2')\n",
"VAR_4.compile(\"\"\"python: 2 \n+\n 2\n\"\"\")\n"
] | [
"def test_compile(self):...\n",
"e = self._makeEngine()\n",
"for p in ('x', 'x/y', 'x/y/z'):\n",
"e.compile(p)\n",
"e.compile('path:a|b|c/d/e')\n",
"e.compile('string:Fred')\n",
"e.compile('string:A$B')\n",
"e.compile('string:a ${x/y} b ${y/z} c')\n",
"e.compile('python: 2 + 2')\n",
"e.compile(\"\"\"python: 2 \n+\n 2\n\"\"\")\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"For",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'"
] |
[
"def FUNC_17(VAR_5):...\n",
"VAR_19 = filescheme.dirbrowser_html(VAR_5).decode('utf-8')\n",
"VAR_20 = bs4.BeautifulSoup(VAR_19, 'html.parser')\n",
"print(VAR_20.prettify())\n",
"VAR_21 = VAR_20('div', id='dirbrowserContainer')[0]\n",
"VAR_42 = VAR_21('ul', class_='parent')\n",
"if not VAR_42:\n",
"VAR_11 = None\n",
"VAR_11 = VAR_42[0].li.a.string\n",
"VAR_15 = []\n",
"VAR_16 = []\n",
"for li in VAR_21('ul', class_='folders')[0]('li'):\n",
"VAR_8 = self.Item(VAR_17=li.a['href'], VAR_18=str(li.a.string))\n",
"for li in VAR_21('ul', class_='files')[0]('li'):\n",
"VAR_15.append(VAR_8)\n",
"VAR_8 = self.Item(VAR_17=li.a['href'], VAR_18=str(li.a.string))\n",
"return self.Parsed(VAR_11=parent, VAR_15=folders, VAR_16=files)\n",
"VAR_16.append(VAR_8)\n"
] | [
"def parse(path):...\n",
"html = filescheme.dirbrowser_html(path).decode('utf-8')\n",
"soup = bs4.BeautifulSoup(html, 'html.parser')\n",
"print(soup.prettify())\n",
"container = soup('div', id='dirbrowserContainer')[0]\n",
"parent_elem = container('ul', class_='parent')\n",
"if not parent_elem:\n",
"parent = None\n",
"parent = parent_elem[0].li.a.string\n",
"folders = []\n",
"files = []\n",
"for li in container('ul', class_='folders')[0]('li'):\n",
"item = self.Item(link=li.a['href'], text=str(li.a.string))\n",
"for li in container('ul', class_='files')[0]('li'):\n",
"folders.append(item)\n",
"item = self.Item(link=li.a['href'], text=str(li.a.string))\n",
"return self.Parsed(parent=parent, folders=folders, files=files)\n",
"files.append(item)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Expr'",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Assign'",
"For",
"Expr'",
"Assign'",
"Return'",
"Expr'"
] |
[
"def FUNC_5(VAR_22: Text, VAR_23: Text, VAR_24: Optional[Fingerprint]=None...\n",
"\"\"\"docstring\"\"\"\n",
"import tarfile\n",
"if VAR_24:\n",
"FUNC_11(VAR_22, VAR_24)\n",
"VAR_43 = os.path.dirname(VAR_23)\n",
"if not os.path.exists(VAR_43):\n",
"os.makedirs(VAR_43)\n",
"for elem in os.scandir(VAR_22):\n",
"tar.add(elem.path, arcname=elem.name)\n",
"shutil.rmtree(VAR_22)\n",
"return VAR_23\n"
] | [
"def create_package_rasa(training_directory: Text, output_filename: Text,...\n",
"\"\"\"docstring\"\"\"\n",
"import tarfile\n",
"if fingerprint:\n",
"persist_fingerprint(training_directory, fingerprint)\n",
"output_directory = os.path.dirname(output_filename)\n",
"if not os.path.exists(output_directory):\n",
"os.makedirs(output_directory)\n",
"for elem in os.scandir(training_directory):\n",
"tar.add(elem.path, arcname=elem.name)\n",
"shutil.rmtree(training_directory)\n",
"return output_filename\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Import'",
"Condition",
"Expr'",
"Assign'",
"Condition",
"Expr'",
"For",
"Expr'",
"Expr'",
"Return'"
] |
[
"@expose('/login/', methods=['GET', 'POST'])...\n",
"if g.user is not None and g.user.is_authenticated:\n",
"return redirect(self.appbuilder.get_url_for_index)\n",
"VAR_10 = LoginForm_db()\n",
"if VAR_10.validate_on_submit():\n",
"VAR_50 = self.appbuilder.sm.auth_user_db(VAR_10.username.data, VAR_10.\n password.data)\n",
"return self.render_template(self.login_template, VAR_37=self.title, VAR_10=\n form, appbuilder=self.appbuilder)\n",
"if not VAR_50:\n",
"flash(as_unicode(self.invalid_login_message), 'warning')\n",
"login_user(VAR_50, remember=False)\n",
"return redirect(self.appbuilder.get_url_for_login)\n",
"return redirect(self.appbuilder.get_url_for_index)\n"
] | [
"@expose('/login/', methods=['GET', 'POST'])...\n",
"if g.user is not None and g.user.is_authenticated:\n",
"return redirect(self.appbuilder.get_url_for_index)\n",
"form = LoginForm_db()\n",
"if form.validate_on_submit():\n",
"user = self.appbuilder.sm.auth_user_db(form.username.data, form.password.data)\n",
"return self.render_template(self.login_template, title=self.title, form=\n form, appbuilder=self.appbuilder)\n",
"if not user:\n",
"flash(as_unicode(self.invalid_login_message), 'warning')\n",
"login_user(user, remember=False)\n",
"return redirect(self.appbuilder.get_url_for_login)\n",
"return redirect(self.appbuilder.get_url_for_index)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Condition",
"Return'",
"Assign'",
"Condition",
"Assign'",
"Return'",
"Condition",
"Expr'",
"Expr'",
"Return'",
"Return'"
] |
[
"@VAR_1.after_request...\n",
"\"\"\"docstring\"\"\"\n",
"if VAR_1.config.get('INCOGNITO') and VAR_13.content_type.startswith('text/html'\n",
"VAR_40 = (request.endpoint == 'report' and request.view_args is not None and\n request.view_args['report_name'] == 'editor')\n",
"return VAR_13\n",
"if not VAR_40:\n",
"VAR_44 = VAR_13.get_data(as_text=True)\n",
"VAR_13.set_data(replace_numbers(VAR_44))\n"
] | [
"@app.after_request...\n",
"\"\"\"docstring\"\"\"\n",
"if app.config.get('INCOGNITO') and response.content_type.startswith('text/html'\n",
"is_editor = (request.endpoint == 'report' and request.view_args is not None and\n request.view_args['report_name'] == 'editor')\n",
"return response\n",
"if not is_editor:\n",
"original_text = response.get_data(as_text=True)\n",
"response.set_data(replace_numbers(original_text))\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Condition",
"Assign'",
"Return'",
"Condition",
"Assign'",
"Expr'"
] |
[
"def FUNC_0(VAR_4, VAR_5=None):...\n",
"VAR_11 = VAR_263.request.args\n",
"if VAR_4 < 0 and len(VAR_11) >= -VAR_4:\n",
"return VAR_11[VAR_4]\n",
"if VAR_4 >= 0 and len(VAR_11) > VAR_4:\n",
"return VAR_11[VAR_4]\n",
"return VAR_5\n"
] | [
"def getarg(position, default=None):...\n",
"args = current.request.args\n",
"if position < 0 and len(args) >= -position:\n",
"return args[position]\n",
"if position >= 0 and len(args) > position:\n",
"return args[position]\n",
"return default\n"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Condition",
"Return'",
"Condition",
"Return'",
"Return'"
] |
[
"def FUNC_7(self):...\n",
"VAR_9 = test.test_src_dir_path(VAR_0)\n",
"self.parser = saved_model_cli.create_parser()\n",
"VAR_10 = self.parser.parse_args(['show', '--dir', VAR_9, '--tag_set',\n 'badtagset'])\n",
"saved_model_cli.show(VAR_10)\n"
] | [
"def testShowCommandErrorNoTagSet(self):...\n",
"base_path = test.test_src_dir_path(SAVED_MODEL_PATH)\n",
"self.parser = saved_model_cli.create_parser()\n",
"args = self.parser.parse_args(['show', '--dir', base_path, '--tag_set',\n 'badtagset'])\n",
"saved_model_cli.show(args)\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"def FUNC_68():...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_192 = FUNC_10()\n",
"if VAR_13.db_name:\n",
"VAR_1.app_modules = VAR_192.get_value('app_modules')\n",
"if not (VAR_1.app_modules and VAR_1.module_app):\n",
"VAR_1.module_app = VAR_192.get_value('module_app')\n",
"VAR_1.module_app, VAR_1.app_modules = {}, {}\n",
"for VAR_219 in FUNC_63(True):\n",
"if VAR_219 == 'webnotes':\n",
"if VAR_13.db_name:\n",
"VAR_219 = 'frappe'\n",
"VAR_1.app_modules.setdefault(VAR_219, [])\n",
"VAR_192.set_value('app_modules', VAR_1.app_modules)\n",
"for VAR_91 in FUNC_62(VAR_219):\n",
"VAR_192.set_value('module_app', VAR_1.module_app)\n",
"VAR_91 = FUNC_56(VAR_91)\n",
"VAR_1.module_app[VAR_91] = VAR_219\n",
"VAR_1.app_modules[VAR_219].append(VAR_91)\n"
] | [
"def setup_module_map():...\n",
"\"\"\"docstring\"\"\"\n",
"_cache = cache()\n",
"if conf.db_name:\n",
"local.app_modules = _cache.get_value('app_modules')\n",
"if not (local.app_modules and local.module_app):\n",
"local.module_app = _cache.get_value('module_app')\n",
"local.module_app, local.app_modules = {}, {}\n",
"for app in get_all_apps(True):\n",
"if app == 'webnotes':\n",
"if conf.db_name:\n",
"app = 'frappe'\n",
"local.app_modules.setdefault(app, [])\n",
"_cache.set_value('app_modules', local.app_modules)\n",
"for module in get_module_list(app):\n",
"_cache.set_value('module_app', local.module_app)\n",
"module = scrub(module)\n",
"local.module_app[module] = app\n",
"local.app_modules[app].append(module)\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'",
"For",
"Condition",
"Condition",
"Assign'",
"Expr'",
"Expr'",
"For",
"Expr'",
"Assign'",
"Assign'",
"Expr'"
] |
[
"async def FUNC_28(self, VAR_5: str, VAR_11: str, VAR_3: List[EventBase],...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_104 = {}\n",
"for VAR_170 in itertools.chain(VAR_3, VAR_2):\n",
"VAR_170.internal_metadata.outlier = True\n",
"VAR_60 = {VAR_170.event_id: VAR_170 for VAR_170 in itertools.chain(VAR_3,\n VAR_2, [VAR_1])}\n",
"VAR_169 = await self.state_handler.compute_event_context(VAR_170)\n",
"VAR_105 = None\n",
"VAR_104[VAR_170.event_id] = VAR_169\n",
"for VAR_170 in VAR_3:\n",
"if (VAR_170.type, VAR_170.state_key) == (VAR_188.Create, ''):\n",
"if VAR_105 is None:\n",
"VAR_105 = VAR_170\n",
"VAR_106 = VAR_105.content.get('room_version', RoomVersions.V1.identifier)\n",
"if VAR_28.identifier != VAR_106:\n",
"VAR_107 = set()\n",
"for VAR_170 in itertools.chain(VAR_3, VAR_2, [VAR_1]):\n",
"for VAR_160 in VAR_170.auth_event_ids():\n",
"for VAR_160 in VAR_107:\n",
"if VAR_160 not in VAR_60:\n",
"VAR_171 = await self.federation_client.get_pdu([VAR_5], VAR_160, VAR_28=\n room_version, outlier=True, timeout=10000)\n",
"for VAR_170 in itertools.chain(VAR_3, VAR_2, [VAR_1]):\n",
"VAR_107.add(VAR_160)\n",
"if VAR_171 and VAR_171.event_id == VAR_160:\n",
"VAR_172 = {(VAR_60[VAR_160].type, VAR_60[VAR_160].state_key): VAR_60[\n VAR_160] for VAR_160 in VAR_170.auth_event_ids() if VAR_160 in VAR_60}\n",
"await self.persist_events_and_notify(VAR_11, [(VAR_170, VAR_104[VAR_170.\n event_id]) for VAR_170 in itertools.chain(VAR_3, VAR_2)])\n",
"VAR_60[VAR_160] = VAR_171\n",
"VAR_0.info('Failed to find auth event %r', VAR_160)\n",
"if VAR_105:\n",
"VAR_108 = await self.state_handler.compute_event_context(VAR_1, old_state=state\n )\n",
"VAR_172[VAR_188.Create, ''] = VAR_105\n",
"event_auth.check(VAR_28, VAR_170, VAR_3=auth_for_e)\n",
"VAR_0.warning('Rejecting %s because %s', VAR_170.event_id, err.msg)\n",
"return await self.persist_events_and_notify(VAR_11, [(VAR_1, VAR_108)])\n",
"if VAR_170 == VAR_1:\n",
"VAR_104[VAR_170.event_id].rejected = RejectedReason.AUTH_ERROR\n"
] | [
"async def _persist_auth_tree(self, origin: str, room_id: str, auth_events:...\n",
"\"\"\"docstring\"\"\"\n",
"events_to_context = {}\n",
"for e in itertools.chain(auth_events, state):\n",
"e.internal_metadata.outlier = True\n",
"event_map = {e.event_id: e for e in itertools.chain(auth_events, state, [\n event])}\n",
"ctx = await self.state_handler.compute_event_context(e)\n",
"create_event = None\n",
"events_to_context[e.event_id] = ctx\n",
"for e in auth_events:\n",
"if (e.type, e.state_key) == (EventTypes.Create, ''):\n",
"if create_event is None:\n",
"create_event = e\n",
"room_version_id = create_event.content.get('room_version', RoomVersions.V1.\n identifier)\n",
"if room_version.identifier != room_version_id:\n",
"missing_auth_events = set()\n",
"for e in itertools.chain(auth_events, state, [event]):\n",
"for e_id in e.auth_event_ids():\n",
"for e_id in missing_auth_events:\n",
"if e_id not in event_map:\n",
"m_ev = await self.federation_client.get_pdu([origin], e_id, room_version=\n room_version, outlier=True, timeout=10000)\n",
"for e in itertools.chain(auth_events, state, [event]):\n",
"missing_auth_events.add(e_id)\n",
"if m_ev and m_ev.event_id == e_id:\n",
"auth_for_e = {(event_map[e_id].type, event_map[e_id].state_key): event_map[\n e_id] for e_id in e.auth_event_ids() if e_id in event_map}\n",
"await self.persist_events_and_notify(room_id, [(e, events_to_context[e.\n event_id]) for e in itertools.chain(auth_events, state)])\n",
"event_map[e_id] = m_ev\n",
"logger.info('Failed to find auth event %r', e_id)\n",
"if create_event:\n",
"new_event_context = await self.state_handler.compute_event_context(event,\n old_state=state)\n",
"auth_for_e[EventTypes.Create, ''] = create_event\n",
"event_auth.check(room_version, e, auth_events=auth_for_e)\n",
"logger.warning('Rejecting %s because %s', e.event_id, err.msg)\n",
"return await self.persist_events_and_notify(room_id, [(event,\n new_event_context)])\n",
"if e == event:\n",
"events_to_context[e.event_id].rejected = RejectedReason.AUTH_ERROR\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
] | [
"Condition",
"Docstring",
"Assign'",
"For",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"Assign'",
"For",
"Condition",
"Condition",
"Assign'",
"Assign'",
"Condition",
"Assign'",
"For",
"For",
"For",
"Condition",
"Assign'",
"For",
"Expr'",
"Condition",
"Assign'",
"Expr'",
"Assign'",
"Expr'",
"Condition",
"Assign'",
"Assign'",
"Expr'",
"Expr'",
"Return'",
"Condition",
"Assign'"
] |
[
"def FUNC_4(self) ->Sequence[GeneratorError]:...\n",
"\"\"\"docstring\"\"\"\n",
"print(f'Generating {self.project_name}')\n",
"self.project_dir.mkdir()\n",
"return [GeneratorError(detail=\n 'Directory already exists. Delete it or use the update command.')]\n",
"self._create_package()\n",
"self._build_metadata()\n",
"self._build_models()\n",
"self._build_api()\n",
"self._reformat()\n",
"return self._get_errors()\n"
] | [
"def build(self) ->Sequence[GeneratorError]:...\n",
"\"\"\"docstring\"\"\"\n",
"print(f'Generating {self.project_name}')\n",
"self.project_dir.mkdir()\n",
"return [GeneratorError(detail=\n 'Directory already exists. Delete it or use the update command.')]\n",
"self._create_package()\n",
"self._build_metadata()\n",
"self._build_models()\n",
"self._build_api()\n",
"self._reformat()\n",
"return self._get_errors()\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Docstring",
"Expr'",
"Expr'",
"Return'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Expr'",
"Return'"
] |
[
"def FUNC_29(self):...\n",
"VAR_5 = self._makeContext()\n",
"self.assertIs(VAR_5.evaluate('nocall:open'), open)\n"
] | [
"def test_open_in_path_expr(self):...\n",
"ec = self._makeContext()\n",
"self.assertIs(ec.evaluate('nocall:open'), open)\n"
] | [
0,
0,
0
] | [
"FunctionDef'",
"Assign'",
"Expr'"
] |
[
"def FUNC_7(self, VAR_13):...\n",
"if VAR_13 is None:\n",
"if not isinstance(self.inputSource, FileInputSource):\n",
"return VAR_13\n",
"VAR_13 = '-'\n",
"if self.inputSource.sourceName.endswith('.bs'):\n",
"VAR_13 = self.inputSource.sourceName[0:-3] + '.html'\n",
"if self.inputSource.sourceName.endswith('.src.html'):\n",
"VAR_13 = self.inputSource.sourceName[0:-9] + '.html'\n",
"VAR_13 = '-'\n"
] | [
"def fixMissingOutputFilename(self, outputFilename):...\n",
"if outputFilename is None:\n",
"if not isinstance(self.inputSource, FileInputSource):\n",
"return outputFilename\n",
"outputFilename = '-'\n",
"if self.inputSource.sourceName.endswith('.bs'):\n",
"outputFilename = self.inputSource.sourceName[0:-3] + '.html'\n",
"if self.inputSource.sourceName.endswith('.src.html'):\n",
"outputFilename = self.inputSource.sourceName[0:-9] + '.html'\n",
"outputFilename = '-'\n"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Condition",
"Condition",
"Return'",
"Assign'",
"Condition",
"Assign'",
"Condition",
"Assign'",
"Assign'"
] |
[
"@CLASS_4('gpl')...\n",
"\"\"\"docstring\"\"\"\n",
"return 'text/html', utils.read_file('html/license.html')\n"
] | [
"@add_handler('gpl')...\n",
"\"\"\"docstring\"\"\"\n",
"return 'text/html', utils.read_file('html/license.html')\n"
] | [
0,
0,
0
] | [
"Condition",
"Docstring",
"Return'"
] |
[
"def FUNC_3(self, VAR_23):...\n",
"assert isinstance(VAR_23, text_type)\n",
"if self.encoding:\n",
"return VAR_23.encode(self.encoding, 'strict')\n",
"return VAR_23\n"
] | [
"def encodeStrict(self, string):...\n",
"assert isinstance(string, text_type)\n",
"if self.encoding:\n",
"return string.encode(self.encoding, 'strict')\n",
"return string\n"
] | [
0,
0,
0,
0,
0
] | [
"FunctionDef'",
"Assert'",
"Condition",
"Return'",
"Return'"
] |
[
"@VAR_0.route('/api/templates', methods=['GET'])...\n",
"\"\"\"docstring\"\"\"\n",
"VAR_73 = {'application': request.args.get('application'), 'backend':\n request.args.get('backend'), 'recent': request.args.get('recent'),\n 'length': request.args.get('length'), 'offset': request.args.get('offset')}\n",
"VAR_88 = FUNC_58('/internal/templates', 'get', VAR_73=params)\n",
"return jsonify({'success': False, 'message': str(err)}), 400\n",
"return jsonify(VAR_88)\n"
] | [
"@gui.route('/api/templates', methods=['GET'])...\n",
"\"\"\"docstring\"\"\"\n",
"params = {'application': request.args.get('application'), 'backend':\n request.args.get('backend'), 'recent': request.args.get('recent'),\n 'length': request.args.get('length'), 'offset': request.args.get('offset')}\n",
"templates_info = query_internal_api('/internal/templates', 'get', params=params\n )\n",
"return jsonify({'success': False, 'message': str(err)}), 400\n",
"return jsonify(templates_info)\n"
] | [
0,
0,
0,
0,
0,
0
] | [
"Condition",
"Docstring",
"Assign'",
"Assign'",
"Return'",
"Return'"
] |