query stringlengths 9 9.05k | document stringlengths 10 222k | metadata dict | negatives listlengths 30 30 | negative_scores listlengths 30 30 | document_score stringlengths 4 10 | document_rank stringclasses 2
values |
|---|---|---|---|---|---|---|
Set font. Set Matplotlibs rcParams to use LaTeX for font rendering. Revert all changes by calling rcdefault() from matplotlib. | def setfont(font=font_default, unicode=True):
# | - setfont
# Use TeX for all figure text!
plt.rc('text', usetex=True)
font = font.lower().replace(" ", "")
if font == 'times':
# Times
font = {'family': 'serif', 'serif': ['Times']}
preamble = r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adjust_matplotlib_settings():\n font = {\"weight\": \"bold\", \"size\": 22, \"family\": \"sans-serif\"}\n matplotlib.rc(\"font\", **font)\n matplotlib.rc(\"text\", usetex=True)\n matplotlib.rcParams[\"mathtext.fontset\"] = \"dejavusans\"",
"def set_font(s: Optional[int] = 14, reset: Optional[bool... | [
"0.79693395",
"0.7837333",
"0.72724414",
"0.7246681",
"0.7214897",
"0.7190593",
"0.71214116",
"0.7098909",
"0.7024721",
"0.6910483",
"0.68902165",
"0.68817675",
"0.6866425",
"0.6845862",
"0.68337435",
"0.67619705",
"0.676082",
"0.6684201",
"0.6683399",
"0.66741335",
"0.666566... | 0.7946944 | 1 |
Calculate overpotential (version 2). | def overpotential2(x, doh):
# | - overpotential2
dooh = ooh_oh_scaling(doh)
dg14 = [doh, x, -x + 2.46, -dooh + 4.92]
m = max(dg14)
return(m - 1.23)
#return doh*do
#__| | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def h2_potential(dist: float) -> float:\n pass",
"def overpotential3(x, doh):\n # | - overpotential3\n dooh = ooh_oh_scaling(doh)\n dg14 = [doh, x, dooh - (x + doh), -dooh + 4.92]\n m = max(dg14)\n return(m - 1.23)\n\n #return doh*do\n #__|",
"def overpotenti... | [
"0.6371512",
"0.6152296",
"0.6152296",
"0.60168374",
"0.6005788",
"0.5821133",
"0.5706565",
"0.56676817",
"0.5640364",
"0.56397086",
"0.5606119",
"0.5594284",
"0.5540267",
"0.55305064",
"0.55050665",
"0.5499045",
"0.5492095",
"0.544175",
"0.5435383",
"0.540637",
"0.53900415",... | 0.694424 | 0 |
Calculate overpotential (version 3). | def overpotential3(x, doh):
# | - overpotential3
dooh = ooh_oh_scaling(doh)
dg14 = [doh, x, dooh - (x + doh), -dooh + 4.92]
m = max(dg14)
return(m - 1.23)
#return doh*do
#__| | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def overpotential2(x, doh):\n # | - overpotential2\n dooh = ooh_oh_scaling(doh)\n dg14 = [doh, x, -x + 2.46, -dooh + 4.92]\n m = max(dg14)\n return(m - 1.23)\n #return doh*do\n #__|",
"def overpotential2(x, doh):\n # | - overpotential2\n dooh = ooh_o... | [
"0.67306256",
"0.67306256",
"0.611761",
"0.6036276",
"0.5971846",
"0.5889118",
"0.5835844",
"0.5786846",
"0.5776279",
"0.56785655",
"0.5668769",
"0.5645312",
"0.56196046",
"0.5615506",
"0.55769",
"0.5573886",
"0.55733645",
"0.55697095",
"0.55594975",
"0.55511606",
"0.55476743... | 0.6762837 | 0 |
Reads text file with nodes and returns the result dict with all objects and their nested properties | def read(self, filePath):
result = {
'coordinates': {
'count': 0,
'nodes': []
},
'element_groups': {
'number_of_elements': 0,
'count': 0,
'groups': []
},
'bars': [],
'materials': {
'count': 0,
'materials': []
},
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_file(filename):\n nodes = {}\n try:\n with open(filename, 'r') as f:\n for line in f:\n params = {}\n device_list = line.split()\n router = device_list[0]\n ip = device_list[1]\n platform = device_list[2]\n ... | [
"0.65386647",
"0.6099965",
"0.60529685",
"0.6005839",
"0.6002847",
"0.59904355",
"0.59661424",
"0.5924216",
"0.5889952",
"0.5873962",
"0.5796389",
"0.5742882",
"0.5738859",
"0.5732563",
"0.57298356",
"0.5715556",
"0.5690946",
"0.56776774",
"0.5675229",
"0.56606585",
"0.564628... | 0.66880167 | 0 |
var = [x3, y3, x3_dot, y3_dot, x4, y4, x4_dot, y4_dot, x5, y5, x5_dot, y5_dot] dx3/dt = p3 dpx3/dt = 2Gm3x3(m4(r34)1.5 + m5(r35)1.5) dy3/dt = p3 dpy3/dt = 2Gm3y3(m4(r34)1.5 + m5(r35)1.5) ... | def manybody(var, t, m3, m4, m5, G):
def r(x1, y1, x2, y2):
return np.sqrt((x1 - x2)**2 + (y1 - y2)**2)**-3
# (x3, y3)
x3 = var[2]
px3 = -G * (m4 * r(var[0], var[1], var[4], var[5]) *
(var[0] - var[4]) + m5 * r(var[0], var[1], var[8], var[9]) *
(var[0] - var[8])... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def derive(params):\n x, y, dx, dy = params\n r = (x ** 2 + y ** 2) ** 0.5\n return np.array([dx, dy, -G * M * x / (r ** 3), -G * M * y / (r ** 3)])",
"def test_y_generate():\n a = Attractor()\n #say x, y, z = [0.1, 0.0, 0.0]\n\n dx = (10.0 * (0.0 - 0.1)) * (80.0-0.0)/10000 + 0.1\n dy = (0.1... | [
"0.6301412",
"0.5902338",
"0.5900668",
"0.5774967",
"0.571807",
"0.5583569",
"0.5568323",
"0.5490414",
"0.5464022",
"0.5455201",
"0.54227054",
"0.5405708",
"0.5388516",
"0.53842306",
"0.53811795",
"0.53736377",
"0.5365458",
"0.5348739",
"0.53481686",
"0.53388417",
"0.5332694"... | 0.6497295 | 0 |
multilevel approvals need to display the roles that have order.approve permissions based on a BPOI custom_field_value where the field name has an "_approver_id" at the end, and a valid role exists on the Group for that cfv field name returns a dictionary of the roles or an empty dict | def is_multilevel_approval(self):
if not self.orderitem_set.first():
return {}
oi = self.orderitem_set.first().cast()
if not oi or not hasattr(oi, 'blueprintitemarguments_set'):
return {}
bpoi = oi.blueprintitemarguments_set.first()
approval_level... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_rbac_field_filters(self, request_context):\n return [\n {'term': {'tenant_id': request_context.owner}},\n ]",
"def user_roles(request):\n\n user = request.user\n\n roles = {\n }\n\n if user.is_superuser:\n for ruleset in RuleSet.RULESET_MODELS.keys():\n ... | [
"0.5326791",
"0.5275147",
"0.5200898",
"0.51850617",
"0.5154925",
"0.5144672",
"0.5113741",
"0.5089122",
"0.5069981",
"0.5027244",
"0.50208485",
"0.5011399",
"0.4989293",
"0.49733752",
"0.4901654",
"0.48940247",
"0.48929912",
"0.48700106",
"0.48694855",
"0.48680052",
"0.48103... | 0.69553465 | 0 |
Return True if this order should be automatically approved. An order should be auto approved if either it's group has auto approve enabled, if the submitter is also an approver on this group, or if all of its order items have environments with auto approve enabled. and now if the multi_level auto approval roles are gra... | def should_auto_approve(self):
if self.group and self.group.allow_auto_approval:
return True
# some orders (like those duplicated by CIT) will not have owners
if self.is_multilevel_approval():
if self.has_all_approver_roles(self.owner, self.group):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_approved(self) -> bool:\n return self.state == Order.OrderState.APPROVED.choice_value",
"def is_auto_approval_allowed(self):\n\n if not self.upload:\n raise ImproperlyConfigured(\n 'Need an upload to call is_auto_approval_allowed()'\n )\n\n return ... | [
"0.7234469",
"0.7211213",
"0.69858086",
"0.69330245",
"0.6764167",
"0.6728061",
"0.6687903",
"0.64949876",
"0.6490349",
"0.63727355",
"0.6219583",
"0.61545944",
"0.6056377",
"0.60156584",
"0.6012165",
"0.59728295",
"0.59324443",
"0.59024364",
"0.5839551",
"0.5806429",
"0.5790... | 0.87011874 | 0 |
This method determines what order process should be taken, and takes it. By default, the process is to email the approvers, but this can be overriden by customers to instead call out to a hook, and that can be overridden by autoapproval (set on the group or env, or by the owner being an approver or a super admin). This... | def start_approval_process(self, request=None):
# done here to avoid circular import
from cbhooks.models import HookPoint
hook_point = HookPoint.objects.filter(name="order_approval").first()
orch_actions = cbhooks._get_orchestration_actions_to_run(hook_point)
if orch_actio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fulfill_order(request_data):\n # First, save this information in a receipt\n receipt = Receipt.objects.create(data=request_data)\n\n # Link the order with the receipt if we can parse it\n reference_number = request_data[\"req_reference_number\"]\n req_bill_to_email = request_data.get(\"req_bill_... | [
"0.52571636",
"0.52387196",
"0.5169821",
"0.5156533",
"0.5121526",
"0.50998837",
"0.50524426",
"0.50479597",
"0.5047176",
"0.49908724",
"0.49373585",
"0.49236974",
"0.4904765",
"0.48912293",
"0.48641482",
"0.48573205",
"0.48481938",
"0.48291686",
"0.4811481",
"0.48071408",
"0... | 0.6203634 | 0 |
Returns the url to access a detail record for this card. | def get_absolute_url(self):
return reverse('card-detail', args=[str(self.id)]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def details_url(self):\n if self._data.get('details_url'):\n path = self._data.get('details_url')\n try:\n path, hash_ = path.split('#')\n hash_ = '#' + hash_\n except ValueError:\n hash_ = ''\n return '{}?from_activity... | [
"0.7252138",
"0.7122791",
"0.6609128",
"0.6586927",
"0.65646684",
"0.6540515",
"0.65038",
"0.64735013",
"0.6464368",
"0.64480615",
"0.642915",
"0.6389873",
"0.63890266",
"0.635177",
"0.631059",
"0.6298563",
"0.6298563",
"0.6298563",
"0.62849885",
"0.62828815",
"0.62722015",
... | 0.7311372 | 0 |
Open an output file and write the found character frequencies | def output_char_freqs(char_freqs):
total_characters = sum(char_freqs.values())
with open("char_freqs.txt", 'w') as f:
for c in sorted(char_freqs.iterkeys()):
freq = (char_freqs[c] * 100.0) / total_characters
f.write("{} = {:.02f}\n".format(c, freq))
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_frequency(count_table, input_file):\n # Opens new file to output to\n with open(f\"{input_file}.out\", \"w\") as text:\n # Total sum of every word's occurrence in the file.\n totalCount = sum(count_table.values())\n\n # Loop through each key and corresponding value in the dictio... | [
"0.672879",
"0.6307966",
"0.62802476",
"0.6165612",
"0.614812",
"0.61398506",
"0.61213356",
"0.61120015",
"0.61103106",
"0.60728496",
"0.60588926",
"0.5969092",
"0.5936891",
"0.5910579",
"0.5895755",
"0.5893644",
"0.58668506",
"0.58516407",
"0.58364403",
"0.5772215",
"0.57327... | 0.7570062 | 0 |
r""" Perform the multiplication by the transposition `(j0, j1)` between the permutations `g_i` and `g_{i+1}`. The modification is local in the sense that it modifies `g_i` and `g_{i+1}` but does not modify the product `g_i g_{i+1}`. The new constellation is | def switch(self, i, j0, j1):
if not self._mutable:
raise ValueError("this constellation is immutable."
" Take a mutable copy first.")
S = SymmetricGroup(list(range(self.degree())))
tr = S((j0, j1))
i = int(i)
if i < 0 or i >= len(self._g):... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def product_on_basis(self, g1, g2):\n return self.monomial(g1 * g2)",
"def FormG():\n for i in range(2):\n for j in range(2):\n G[i, j] = 0.0\n for k in range(2):\n for l in range(2):\n G[i, j] = G[i, j] + P[k, l] * (TT[i, j, k, l] ... | [
"0.6071219",
"0.58295655",
"0.5754315",
"0.5744784",
"0.5714475",
"0.5673767",
"0.5559407",
"0.5550118",
"0.54759073",
"0.5454284",
"0.53635615",
"0.5355538",
"0.53540826",
"0.5351326",
"0.52823526",
"0.52660817",
"0.5223772",
"0.521385",
"0.5199376",
"0.5188203",
"0.51872635... | 0.66472405 | 0 |
r""" Return the Euler characteristic of the surface. | def euler_characteristic(self):
return Integer(self.degree() * 2 -
sum(sum(j - 1 for j in self.profile(i))
for i in range(self.length()))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def euler(faces, edges, verticies):\n\n # Return the calculated value\n return verticies + edges - faces",
"def imu_get_euler(self):\n return self.imu.get_euler()",
"def eccentricity(self):\n return sqrt(self.f * 2 - self.f ** 2)",
"def fahrenheit(self):\n return (self.celsius * 9 ... | [
"0.65330803",
"0.64535654",
"0.62011623",
"0.60929686",
"0.6086542",
"0.6070277",
"0.59088135",
"0.5883197",
"0.5880621",
"0.5868365",
"0.58484817",
"0.58406955",
"0.58141273",
"0.5813703",
"0.5791044",
"0.57704276",
"0.57662755",
"0.57604665",
"0.5753744",
"0.5717954",
"0.57... | 0.75447106 | 0 |
r""" Return the genus of the surface. | def genus(self):
return 1 - self.euler_characteristic() // 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def genes():\n return [\"b2935\", \"b0723\", \"b0451\"]",
"def gene(self, idx):\r\n return self.genes[idx]",
"def G(self):\n return self._properties['G']",
"def genres(self):\n if \"genres\" in self._prop_dict:\n return self._prop_dict[\"genres\"]\n else:\n ... | [
"0.6060225",
"0.60602057",
"0.598353",
"0.5891596",
"0.5854243",
"0.5854243",
"0.58437705",
"0.5838291",
"0.58079755",
"0.58079755",
"0.5725381",
"0.5688497",
"0.5665119",
"0.5653446",
"0.56409246",
"0.560487",
"0.55763316",
"0.55609643",
"0.55455524",
"0.5544166",
"0.5538799... | 0.70825785 | 0 |
r""" Test of isomorphism. Return ``True`` if the constellations are isomorphic (i.e. related by a common conjugacy) and return the permutation that conjugate the two permutations if ``return_map`` is ``True`` in such a way that ``self.relabel(m) == other``. | def is_isomorphic(self, other, return_map=False):
if return_map:
if not(self.degree() == other.degree() and
self.length() == other.length()):
return False, None
sn, sn_map = self.relabel(return_map=True)
on, on_map = other.relabel(return_map... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relabel(self, perm=None, return_map=False):\n if perm is not None:\n g = [[None] * self.degree() for _ in range(self.length())]\n for i in range(len(perm.domain())):\n for k in range(self.length()):\n g[k][perm(i)] = perm(self._g[k](i))\n ... | [
"0.6206438",
"0.5143112",
"0.51368237",
"0.5134728",
"0.5094439",
"0.50741196",
"0.4996991",
"0.49951893",
"0.49626917",
"0.49429464",
"0.4941241",
"0.4935552",
"0.49249017",
"0.49178264",
"0.48804057",
"0.48664072",
"0.48632103",
"0.4847054",
"0.48232257",
"0.4772884",
"0.47... | 0.6701239 | 0 |
r""" Relabel ``self``. If ``perm`` is provided then relabel with respect to ``perm``. Otherwise use canonical labels. In that case, if ``return_map`` is provided, the return also the map used for canonical labels. | def relabel(self, perm=None, return_map=False):
if perm is not None:
g = [[None] * self.degree() for _ in range(self.length())]
for i in range(len(perm.domain())):
for k in range(self.length()):
g[k][perm(i)] = perm(self._g[k](i))
return Co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relabeled(self, memo=None, labels=None):\n from copy import deepcopy\n\n self._deepcopy_relabel_ = True\n self._deepcopy_labels_ = labels\n new = deepcopy(self, memo)\n del self._deepcopy_relabel_\n del self._deepcopy_labels_\n return new",
"def relabeled(self... | [
"0.5402569",
"0.5399554",
"0.53615564",
"0.51162606",
"0.50826514",
"0.50425136",
"0.5004644",
"0.49456677",
"0.4891772",
"0.47967744",
"0.47023624",
"0.4668362",
"0.46495047",
"0.4648723",
"0.45297396",
"0.45194167",
"0.45090672",
"0.4478269",
"0.4468777",
"0.44670847",
"0.4... | 0.7472794 | 0 |
r""" Act on ``self`` as the braid group generator that exchanges position `i` and `i+1`. | def braid_group_action(self, i):
if i < 0 or i >= self.length():
txt = "i should be between 0 and {}"
raise ValueError(txt.format(self.length() - 1))
j = i + 1
if j == self.length(): # wrap around the cylinder
j = 0
h = self.copy()
si = self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def group(self):\n yield self.current\n # start enumerate at 1 because we already yielded the last saved item\n for num, item in enumerate(self.iterator, 1):\n self.current = item\n if num == self.limit:\n break\n yield item\n else:\n ... | [
"0.64083403",
"0.5906254",
"0.58961093",
"0.5846462",
"0.5837545",
"0.57587385",
"0.57553136",
"0.56698734",
"0.5620692",
"0.5587994",
"0.55445355",
"0.54977274",
"0.548787",
"0.5449288",
"0.543855",
"0.5415852",
"0.5415852",
"0.5374004",
"0.5369412",
"0.5360109",
"0.5360109"... | 0.6528009 | 0 |
r""" Return the graph of the action of the braid group. The action is considered up to isomorphism of constellation. | def braid_group_orbit(self):
from sage.graphs.digraph import DiGraph
G = DiGraph(multiedges=True, loops=True)
waiting = [self.relabel()]
while waiting:
c = waiting.pop()
G.add_vertex(c)
for i in range(self.length()):
cc = self.braid_g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def braid_group_action(self):\n G = []\n for c in self:\n c = c.relabel()\n if any(c in g for g in G):\n continue\n G.append(c.braid_group_orbit())\n return G",
"def getGraphWhichCouldBeWorsenedBySwitch(self):\n makeLayers = self.makeLay... | [
"0.6492667",
"0.59466064",
"0.59110755",
"0.5573219",
"0.55282164",
"0.54976255",
"0.5481925",
"0.5476177",
"0.54650325",
"0.54639196",
"0.5454971",
"0.5451179",
"0.5451179",
"0.5451179",
"0.5451179",
"0.5437864",
"0.5429981",
"0.54247445",
"0.54101396",
"0.53715026",
"0.5352... | 0.64895546 | 1 |
Iterator over all constellations of given degree and length. | def __iter__(self):
from itertools import product
if self._length == 1:
if self._degree == 1:
yield self([[0]])
return
S = self._sym
for p in product(S, repeat=self._length - 1):
if self._connected and not perms_are_connected(p, self.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n for i in range(len(self.ks)):\n yield self.get_neighs([i]), self.get_sp_rel_pos([i]),\\\n [self.ks[i]], self.iss",
"def elements(self, degree):\r\n \r\n elements = []\r\n darts = set(self.darts())\r\n\r\n list_of_alpha_value = ran... | [
"0.5840303",
"0.5709773",
"0.568631",
"0.5642443",
"0.55471396",
"0.5542346",
"0.5496706",
"0.54941493",
"0.54905415",
"0.54516786",
"0.5417595",
"0.540483",
"0.53563493",
"0.5346115",
"0.5343145",
"0.5294001",
"0.5267207",
"0.52572596",
"0.5229214",
"0.5209834",
"0.5173835",... | 0.5743113 | 1 |
r""" Return a list of graphs that corresponds to the braid group action on ``self`` up to isomorphism. | def braid_group_action(self):
G = []
for c in self:
c = c.relabel()
if any(c in g for g in G):
continue
G.append(c.braid_group_orbit())
return G | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def braid_group_orbits(self):\n return [g.vertices() for g in self.braid_group_action()]",
"def braid_group_orbit(self):\n from sage.graphs.digraph import DiGraph\n\n G = DiGraph(multiedges=True, loops=True)\n waiting = [self.relabel()]\n\n while waiting:\n c = waiti... | [
"0.66406924",
"0.6160372",
"0.59837",
"0.5843754",
"0.567677",
"0.5655217",
"0.5581463",
"0.545821",
"0.54224503",
"0.5372676",
"0.5372676",
"0.53278506",
"0.5290426",
"0.5258509",
"0.52540493",
"0.52470595",
"0.52439123",
"0.5237683",
"0.5210628",
"0.5210628",
"0.5198323",
... | 0.69799006 | 0 |
r""" Return the orbits under the action of braid group. | def braid_group_orbits(self):
return [g.vertices() for g in self.braid_group_action()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def braid_group_action(self):\n G = []\n for c in self:\n c = c.relabel()\n if any(c in g for g in G):\n continue\n G.append(c.braid_group_orbit())\n return G",
"def braid_group_orbit(self):\n from sage.graphs.digraph import DiGraph\n\n ... | [
"0.74268705",
"0.6136093",
"0.6034799",
"0.60311764",
"0.55835646",
"0.5429353",
"0.53823596",
"0.5372792",
"0.5361682",
"0.5346896",
"0.5335885",
"0.5329873",
"0.5266162",
"0.5233149",
"0.5224166",
"0.5222144",
"0.5222144",
"0.5222144",
"0.52120423",
"0.52108264",
"0.5184408... | 0.7455153 | 0 |
r""" Return a set of isomorphism representative of ``self``. | def isomorphism_representatives(self):
result = set()
for c in self:
cc = c.relabel()
if cc not in result:
result.add(cc)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_orphans(self):\n return self.orphans",
"def all_hyponyms(self):\n hyponyms = []\n for path in self.hyponym_paths():\n for synset in path:\n if synset is not self:\n hyponyms.append(synset)\n return set(hyponyms)",
"def automata(se... | [
"0.7099448",
"0.62319756",
"0.60432094",
"0.5951952",
"0.5868608",
"0.5780371",
"0.5775545",
"0.57626015",
"0.56999815",
"0.56807095",
"0.56562036",
"0.5646771",
"0.5637675",
"0.55941945",
"0.55751",
"0.55503714",
"0.5548593",
"0.5541508",
"0.5530613",
"0.5519788",
"0.5516649... | 0.785068 | 0 |
r""" Return the domain of a single permutation (before initialization). | def perm_sym_domain(g):
if isinstance(g, (tuple, list)):
if isinstance(g[0], tuple):
return set().union(*g)
else:
return set(g)
elif isinstance(g, str): # perms given as strings of cycles
assert g.startswith('(') and g.endswith(')')
domain = set().union(*... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_domain(self):\n self.ensure_one()\n domain = []\n return domain",
"def par_domain(self):",
"def get_possible_domain(self):\n return self.possible_domain",
"def index_in_domain(self):\n\t\treturn int((self.position - self.domain.x.min())/self.domain.dx)",
"def get_nomina... | [
"0.6118273",
"0.594686",
"0.5925524",
"0.5884562",
"0.58589494",
"0.5820458",
"0.5781994",
"0.57714754",
"0.57542837",
"0.57538015",
"0.57500744",
"0.56633013",
"0.5628366",
"0.56257564",
"0.56076795",
"0.55817103",
"0.55817103",
"0.55817103",
"0.55817103",
"0.5511974",
"0.55... | 0.61023664 | 1 |
r""" Return canonical labels for ``x``, ``y`` that starts at ``j0`` | def perms_canonical_labels_from(x, y, j0, verbose=False):
n = len(x)
k = 0
mapping = [None] * n
waiting = [[] for i in range(len(y))]
while k < n:
if verbose:
print("complete from {}".format(j0))
# initialize at j0
mapping[j0] = k
waiting[0].append(j0)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def groupByLabel( y ):\n index = []\n for i in np.unique(y): # pour toutes les classes\n ind, = np.where(y==i)\n index.append(ind)\n \n return index",
"def labels(self):\n return self.label(self.p_y_given_x)",
"def canonical_coloring_label_1(G,c):\n \n H = G.copy()\n ... | [
"0.62198675",
"0.5940839",
"0.5851815",
"0.58237207",
"0.57229173",
"0.57103705",
"0.56514764",
"0.5646222",
"0.56113136",
"0.5605356",
"0.5596431",
"0.5590204",
"0.55876946",
"0.5576302",
"0.5551425",
"0.55448896",
"0.554466",
"0.55272055",
"0.5512352",
"0.5511325",
"0.55113... | 0.6669979 | 0 |
Return the conjugate of the permutation `p` by the permutation `s`. | def perm_conjugate(p, s):
q = [None] * len(p)
for i in range(len(p)):
q[s[i]] = s[p[i]]
return q | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def josephus(self, m, n, s = 1):\n from collections import deque\n m -= 1\n if s <= 0:\n s = 1\n Q = deque(range(n))\n perm = []\n while len(Q) > s:\n for dp in xrange(m):\n Q.append(Q.popleft())\n perm.append(Q.popleft())\n ... | [
"0.6476254",
"0.60571045",
"0.6049296",
"0.60237247",
"0.5918237",
"0.58483875",
"0.5842256",
"0.5837338",
"0.57588613",
"0.564905",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
"0.5644281",
... | 0.769557 | 0 |
add all the urls in the urls bag to selector | def register_urls(store, config):
url_bag = config['url_bag']
selector = config['selector']
bag = Bag(url_bag)
try:
bag = store.get(bag)
except NoBagError:
logging.debug('tiddlywebplugins.urls Error: No bag found for urls. Please create bag \"%s\".' % url_bag)
raise NoBa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def urls(self, urls):\n\n self._urls = urls",
"def urls(self) -> list[str]:\r\n ...",
"def get_urls(self, **kwargs):\n pass # pragma: no cover",
"def __init__(self):\n self._urls = []",
"def mutate_urls(self, mutator):",
"def __init__(self, *urls):\n\n self.urlpatterns... | [
"0.6649948",
"0.6330896",
"0.6220986",
"0.61670214",
"0.60134584",
"0.6012786",
"0.5985614",
"0.5910516",
"0.5810616",
"0.56931007",
"0.5624071",
"0.56206536",
"0.5610914",
"0.55701613",
"0.5558696",
"0.55520993",
"0.55399317",
"0.55315363",
"0.5458942",
"0.544169",
"0.544112... | 0.65286016 | 1 |
add a url, defined by a tiddler, to selector | def register_url(selector, tiddler):
replaced = False
for index, (regex, handler) in enumerate(selector.mappings):
if regex.match(tiddler.title) is not None or selector.parser(tiddler.title) == regex.pattern:
handler['GET'] = get_handler
selector.mappings[index] = (re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def url_set(self, url):\n self.request('/v1.1/url', 'POST', body={'url': url})",
"def set_url(self, url):\n self.url = url",
"def _set_url(self): \n self.url = self.geturl()",
"def set_url(self, url):\n super(Cabling, self).set_url(url)",
"def url_changed(self, url):\r\n ... | [
"0.5984198",
"0.57857734",
"0.57633865",
"0.5631861",
"0.55952954",
"0.5581549",
"0.5554614",
"0.5512297",
"0.54919946",
"0.5471422",
"0.54332876",
"0.5422737",
"0.53958774",
"0.53958774",
"0.53958774",
"0.53958774",
"0.53958774",
"0.53958774",
"0.53958774",
"0.53569704",
"0.... | 0.6837426 | 0 |
entry point for /urls/refresh | def refresh_urls(environ, start_response):
store = environ['tiddlyweb.store']
config = environ['tiddlyweb.config']
register_urls(store, config)
start_response('200 OK', [('Content-Type', 'text/html; charset=utf-8')])
return 'All URLs have been updated' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh(self, url, args, cancellationSignal):\n pass",
"def refresh_view():\n pass",
"def refresh(self):\n self.dto = self.res.get()\n log.debug(f\"Refreshed {self.url}\")",
"def update(self):\n # TO DO for updating urls if changed\n pass",
"def refresh(self):\n ... | [
"0.74341965",
"0.73502296",
"0.6526179",
"0.64411074",
"0.6408626",
"0.6408626",
"0.638373",
"0.6298281",
"0.62200224",
"0.62200224",
"0.62200224",
"0.6215422",
"0.6215422",
"0.61655086",
"0.61260957",
"0.6121222",
"0.60829985",
"0.59700006",
"0.5942193",
"0.59002626",
"0.588... | 0.74611336 | 0 |
Drop collection if it exists. | def drop_collection(self, db_name: str = None, collection_name: str = None, **kwargs) -> bool:
db: Database = self.db if db_name is None else self.client[db_name]
coll: Collection = self.coll if collection_name is None else db[collection_name]
if(coll.name in db.list_collection_names()):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drop_collection(self, collection):\n self.database.drop_collection(collection)",
"def remove_collection(cls, collection_name):\n cls.log.debug('Removing collection: {}'.format(collection_name))\n cls.conn[cls.DATABASE_NAME][collection_name].drop()\n cls.log.info('Collection succes... | [
"0.79765016",
"0.7429648",
"0.7095391",
"0.66072655",
"0.660125",
"0.65903586",
"0.6577248",
"0.65324676",
"0.6467471",
"0.64559305",
"0.6452855",
"0.6444502",
"0.6412875",
"0.64091974",
"0.6406886",
"0.61746615",
"0.6164482",
"0.61408913",
"0.61309135",
"0.61051005",
"0.5991... | 0.75118566 | 1 |
Finds documents in a collection using the defined filter. | def find(self, filter_: dict, projection: dict = None, db_name: str = None, collection_name: str = None, **kwargs) -> list[dict]:
db: Database = self.db if db_name is None else self.client[db_name]
coll: Collection = self.coll if collection_name is None else db[collection_name]
return list(coll... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(self, collection, query=None, filter=None):\n return self.__db[collection].find(query, filter)",
"def filter(self, where: t.Mapping[str, t.Any]) -> MongoDBQuerySet:\n\n self.cursor = self.collection.find(where)\n return self",
"def find(self, *args, **kwds):\n return se... | [
"0.6996083",
"0.66151667",
"0.6611664",
"0.65968776",
"0.6405217",
"0.63827103",
"0.6338837",
"0.6318726",
"0.62788284",
"0.6275715",
"0.6273338",
"0.62592405",
"0.61913306",
"0.6134686",
"0.61340094",
"0.61247253",
"0.61186266",
"0.6106573",
"0.60950285",
"0.60909677",
"0.60... | 0.71586084 | 0 |
Check if the given collection exists. | def collection_exists(self, db_name: str = None, collection_name: str = None, **kwargs) -> bool:
db: Database = self.db if db_name is None else self.client[db_name]
coll: Collection = self.coll if collection_name is None else db[collection_name]
return coll.name in db.list_collection_names() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collection_exist(database_name, collection_name):\n if not database_exist(database_name):\n return False\n\n with MongoDBConnection() as mongo:\n collection_list = mongo.connection[database_name].list_collection_names()\n\n exist_flag = True\n if collection_name not in collection_list... | [
"0.8027039",
"0.6853273",
"0.68063295",
"0.6755768",
"0.6737601",
"0.6534181",
"0.6455403",
"0.6444901",
"0.6408704",
"0.6370947",
"0.6337674",
"0.622433",
"0.61307335",
"0.5982225",
"0.59783244",
"0.59587634",
"0.5948145",
"0.594031",
"0.59363306",
"0.59103423",
"0.5906758",... | 0.8129488 | 0 |
Produce a summary table outlining the range of stellar parameters reported. | def stellar_parameter_range(database, wg=None):
if wg is None:
nodes = database.retrieve("SELECT id, wg, name FROM nodes")
else:
nodes = database.retrieve("SELECT id, wg, name FROM nodes WHERE wg = %s",
(utils.wg_as_int(wg), ))
rows = []
for node_id, node_wg, node_name in n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stellar_parameter_summary(database, wg=None):\n\n # Get node ids.\n if wg is None:\n nodes = database.retrieve(\"\"\"SELECT id, wg, name FROM nodes\"\"\")\n else:\n nodes = database.retrieve(\n \"\"\"SELECT id, wg, name FROM nodes WHERE wg = %s\"\"\",\n (utils.wg_as... | [
"0.67677605",
"0.60010123",
"0.58716077",
"0.5750357",
"0.5594084",
"0.5531156",
"0.5510364",
"0.5496952",
"0.54359865",
"0.5423504",
"0.5386097",
"0.5314283",
"0.52973235",
"0.5284618",
"0.52788186",
"0.52577543",
"0.5239996",
"0.5227156",
"0.5226967",
"0.51768273",
"0.51728... | 0.67874604 | 0 |
Load the topology configuration | def load_topology_config(self) -> None:
config_path = os.path.join(
self.kafka_topology_path,
f'{self.cluster_type}.yaml',
)
self.log.debug("Loading configuration from %s", config_path)
if os.path.isfile(config_path):
topology_config = load_yaml_config... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _loadconfig(self):\n\n # Get the Topology, from the topology layout file\n topo = {}\n with open(self._autoconfig_filename, \"r\") as stream:\n try:\n topo = yaml.load(stream)\n if \"metadata\" in topo:\n self._metadata = topo[\"m... | [
"0.7672456",
"0.73971033",
"0.65449417",
"0.65132695",
"0.6506949",
"0.64924914",
"0.64614207",
"0.6428533",
"0.64034027",
"0.6309796",
"0.6276278",
"0.62671906",
"0.6206082",
"0.6181302",
"0.61583304",
"0.61161435",
"0.6107723",
"0.5951282",
"0.5951282",
"0.59263057",
"0.590... | 0.7790506 | 0 |
Cluster topology iterator. Iterate over all the topologies available in config. | def iter_configurations(kafka_topology_base_path: str | None = None) -> Iterator[TopologyConfiguration]:
if not kafka_topology_base_path:
config_dirs = get_conf_dirs()
else:
config_dirs = [kafka_topology_base_path]
types = set()
for config_dir in config_dirs:
new_types = [x for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nodes_iter(topology):\n return topology.nodes_iter()",
"def __iter__(self):\n return self._clusters.__iter__()",
"def neighbors_iter(node, topology):\n return topology[node]",
"def topologies(self):\n return self._topologies",
"def __iter__(self):\n for i in range(len(self.ks... | [
"0.65686154",
"0.62117237",
"0.6061402",
"0.5830486",
"0.5764182",
"0.56655353",
"0.56236356",
"0.55413836",
"0.54753095",
"0.54628253",
"0.5443994",
"0.5441247",
"0.54330224",
"0.5392898",
"0.53579277",
"0.5352413",
"0.5346233",
"0.52820474",
"0.5280862",
"0.5266059",
"0.525... | 0.6412919 | 1 |
Get reference to VideoTrack, VRTrack and KeyTrack | def setupTracks(self):
# get the already loaded video track
self.video = VideoTrack.lastInstance()
# get the already loaded VR track
self.vr = extensions.VRCamTrack.lastInstance()
# get the already loaded input track
self.keyboard = KeyTrack.lastInstance() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rt_track(self):\n return self._rt_track",
"def tracks(self):\r\n return None",
"def get_track(a=None, id=0):\n return {\n 'track':'info'\n }",
"def ReleaseTrack(self):\n return self._common_type.ReleaseTrack()",
"def track(self):\r\n\t\treturn self._track",
"... | [
"0.60820705",
"0.59286857",
"0.57636386",
"0.576146",
"0.57347673",
"0.56171626",
"0.56146467",
"0.55608827",
"0.5551802",
"0.552835",
"0.54968256",
"0.54877746",
"0.541966",
"0.53950244",
"0.5366661",
"0.52890897",
"0.5202496",
"0.51652795",
"0.51080203",
"0.5101694",
"0.507... | 0.68375033 | 0 |
Return a header for a week as a table row. | def formatweekheader(self):
s = ''.join(self.formatweekday(i) for i in self.iterweekdays())
return '<tr class="weekheader">%s</tr>' % s | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def formatWeekHeader(self):\n s = ''.join(self.formatWeekDay(i) for i in self.iterweekdays())\n return '<tr>%s</tr>' % s",
"def generate_header_row(self):\n weekday_abbrev = (\"M\",\"T\",\"W\",\"T\",\"F\",\"S\",\"S\")\n weeknames = self._create_week_dates_text()\n self.add_elem... | [
"0.83022475",
"0.77998996",
"0.6989413",
"0.6796328",
"0.66150665",
"0.64307827",
"0.64120406",
"0.6360893",
"0.6360893",
"0.62918156",
"0.62874126",
"0.6267701",
"0.62578714",
"0.62022454",
"0.613561",
"0.61108404",
"0.60888946",
"0.6085412",
"0.6084146",
"0.6062262",
"0.604... | 0.8143175 | 1 |
Create a playlist from data | def create_playlist(self, data):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_playlist(self, playlist_name):\n print(\"create_playlist needs implementation\")",
"async def playlist(self, data, msg):\n for i in data['queue']:\n print(i)\n self.player[msg.guild.id]['queue'].append(\n {'title': i, 'author': msg})",
"def create_p... | [
"0.72819227",
"0.6880124",
"0.6879969",
"0.6873635",
"0.6817086",
"0.6795184",
"0.67344636",
"0.66905725",
"0.66850626",
"0.66752607",
"0.660798",
"0.6600571",
"0.65985465",
"0.65245926",
"0.64953935",
"0.64728314",
"0.64603925",
"0.64594024",
"0.64221084",
"0.6391059",
"0.63... | 0.8826154 | 0 |
Scale and transform dataset_train and dataset_test | def transform_data(dataset_train, dataset_test):
#transform dataset using fit_transform
dataset_train = scaler.fit_transform(dataset_train)
#transform dataset using transform (does not influence teaching)
dataset_test = scaler.transform(dataset_test)
return dataset_train, dataset_test | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale(self, X_train, X_test):\n\n #X_train, X_test, y_train, y_test = self.split_X_y_sets()\n self.scaler.fit(X_train)\n X_train_sc = self.scaler.transform(X_train)\n X_test_sc = self.scaler.transform(X_test)\n\n return X_train_sc, X_test_sc #, y_train, y_test",
"def scale(... | [
"0.7982695",
"0.7745152",
"0.75989187",
"0.7581872",
"0.74921095",
"0.73439115",
"0.73353124",
"0.71642035",
"0.70274293",
"0.6987155",
"0.6936766",
"0.68020487",
"0.67546535",
"0.66917396",
"0.6674111",
"0.6663296",
"0.6662013",
"0.664792",
"0.66287935",
"0.6620944",
"0.6549... | 0.8070444 | 0 |
Take training and testing datasets, reshape them | def reshape_datasets(dataset_train, dataset_test, predict_window):
x_train, y_train = create_my_dataset(dataset_train, predict_window)
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
x_test, y_test = create_my_dataset(dataset_test, predict_window)
x_test = np.reshape(x_test, (x_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_split():\n x_train = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TRAIN, \"images.npy\"))\n y_train = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TRAIN, \"label.npy\"))\n x_test = np.load(os.path.join(svhn.DEFAULT_PREPROCESSED_DATA_FOLDER, svhn.TEST, \"ima... | [
"0.6986001",
"0.69141376",
"0.6906754",
"0.6873168",
"0.6716336",
"0.6695948",
"0.66744184",
"0.66512346",
"0.6641296",
"0.6628172",
"0.6615249",
"0.65962434",
"0.6586866",
"0.6573582",
"0.6560157",
"0.6554797",
"0.6550413",
"0.6490638",
"0.64868975",
"0.64868975",
"0.6460537... | 0.78979605 | 0 |
Take amazon_id and create a path where model will be saved | def get_model_path(amazon_id):
path_to_model = '/home/vagrant/src/' + str(amazon_id) + '.h5'
return path_to_model | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_convert_id_to_path(self):\n backend = BackendS3(**self.config)\n filename = 'demo-test.tar.gz'\n id = utils.generate_id(filename)\n parts = backend.id_to_path(id)\n self.assertEquals(6, len(parts))\n self.assertEquals(filename, parts[5])",
"def save(self, path):... | [
"0.5979265",
"0.56693",
"0.5590928",
"0.55742717",
"0.55504394",
"0.55044574",
"0.54747677",
"0.54587054",
"0.5438993",
"0.5434625",
"0.54258674",
"0.53654045",
"0.5354241",
"0.5346739",
"0.5338448",
"0.5321228",
"0.53100646",
"0.52974033",
"0.5281441",
"0.5269057",
"0.522831... | 0.6483796 | 0 |
Test set permission on permission queryset. | def test_set_permission(self):
collection = Collection.objects.create(
contributor=self.owner, name="Test collection 2"
)
self.assertEqual(collection.get_permission(self.user1), Permission.NONE)
self.assertEqual(self.collection.get_permission(self.user1), Permission.NONE)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_permissions(self):\n self.assert_('admin' in get_model_perms(Group))",
"def test_permission(self):\n response = self._get()\n self.assertEqual(response.status_code, 200)",
"def test_permission(self):\n response = self._get()\n self.assertEqual(response.status_code, 2... | [
"0.6841924",
"0.6838543",
"0.6838543",
"0.68142956",
"0.68014246",
"0.67887133",
"0.67423177",
"0.66851014",
"0.6493589",
"0.64836544",
"0.6429991",
"0.6416053",
"0.64121246",
"0.6395648",
"0.63359106",
"0.6296586",
"0.6296586",
"0.6296586",
"0.6296586",
"0.6286959",
"0.62470... | 0.74670863 | 0 |
Testing the size of the bucket. | def testBucketSize(self):
b = SomeBucket()
fit = b.add(1000)
self.assertEqual(100, fit) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def length(self):\n # TODO: Count number of key-value entries in each of the buckets\n return self.size\n # for bucket in self.buckets():",
"def check_s3_object_size(bucket, key_name):\n\n tracer.put_metadata('object', f's3://{bucket}/{key_name}')\n\n try:\n size = s3_resource.O... | [
"0.7147277",
"0.6996279",
"0.6847987",
"0.6767543",
"0.6754298",
"0.6752591",
"0.6739856",
"0.6722771",
"0.67147684",
"0.6647663",
"0.6638176",
"0.66341555",
"0.66257226",
"0.66257226",
"0.66202897",
"0.6577325",
"0.6546135",
"0.6529772",
"0.6529772",
"0.6529772",
"0.6521938"... | 0.82327473 | 0 |
Testing the bucket's drain rate. | def testBucketDrain(self):
b = SomeBucket()
fit = b.add(1000)
self.clock.set(10)
fit = b.add(1000)
self.assertEqual(20, fit) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_bucketEmpty(self):\n b = SomeBucket()\n b.add(20)\n self.clock.set(9)\n empty = b.drip()\n self.assertFalse(empty)\n self.clock.set(10)\n empty = b.drip()\n self.assertTrue(empty)",
"def testBucketSize(self):\n b = SomeBucket()\n fit ... | [
"0.6294504",
"0.59363806",
"0.5895996",
"0.58327687",
"0.5816668",
"0.5800142",
"0.5753974",
"0.5621151",
"0.5549094",
"0.54925025",
"0.54634225",
"0.54586846",
"0.5455775",
"0.54529107",
"0.54294443",
"0.542197",
"0.54173005",
"0.5411244",
"0.5395587",
"0.5392055",
"0.537529... | 0.7891743 | 0 |
L{htb.Bucket.drip} returns C{True} if the bucket is empty after that drip. | def test_bucketEmpty(self):
b = SomeBucket()
b.add(20)
self.clock.set(9)
empty = b.drip()
self.assertFalse(empty)
self.clock.set(10)
empty = b.drip()
self.assertTrue(empty) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty(self) -> bool:\n return self.qsize() == 0",
"def empty(self): \n return self.qsize() == 0",
"def is_empty(self):\n return self.url_queue.empty()",
"def empty(self) -> bool:\n return len(self.q) == 0",
"def empty(self) -> bool:\n return len(self.q) == 0",
"def... | [
"0.617101",
"0.6163718",
"0.6154656",
"0.6055382",
"0.6055382",
"0.6050573",
"0.6050573",
"0.6033851",
"0.5994888",
"0.5990675",
"0.59903485",
"0.5983656",
"0.59805137",
"0.597945",
"0.59720147",
"0.5953855",
"0.5953855",
"0.59519565",
"0.5950768",
"0.5931174",
"0.5916114",
... | 0.7007695 | 0 |
converting samples from CausalTimeBank | def convert_causal_timebank(self):
mismatch = 0
data_path = self.dir_path + "causal_timebank/Causal-TimeBank-CAT"
all_files = os.listdir(data_path)
# parser = ET.XMLParser(encoding="utf-8")
data = pd.DataFrame(columns=self.scheme_columns)
for file in all_files:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collater(self, samples):\r\n raise NotImplementedError",
"def getBarySamples(self):\n self.XC1Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.XC2Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c1Fields = np.zeros([self.nSample, self.nCell_cfd])\n self.c2Fi... | [
"0.59806293",
"0.5669124",
"0.5656576",
"0.559988",
"0.5557066",
"0.5506399",
"0.5471757",
"0.5451745",
"0.54195935",
"0.5409302",
"0.5393151",
"0.53899634",
"0.53889066",
"0.53755903",
"0.53644824",
"0.5340264",
"0.5337269",
"0.53142154",
"0.53132826",
"0.5286043",
"0.528449... | 0.601331 | 0 |
converting causal and noncausal samples from EventStoryLines | def convert_eventstorylines_v1(self, version="1.5"):
mismatch = 0
docs_path = self.dir_path + "eventstorylines/annotated_data/v" + version
# creating a dictionary of all documents
data = pd.DataFrame(columns=self.scheme_columns)
for folder in os.listdir(docs_path):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_semeval_2010_8(self):\n e1_tag = [\"<e1>\", \"</e1>\"]\n e2_tag = [\"<e2>\", \"</e2>\"]\n global mismatch\n mismatch = 0\n\n def extract_samples(all_lines, split):\n samples = pd.DataFrame(columns=self.scheme_columns)\n # each sample has three li... | [
"0.5615938",
"0.552843",
"0.54696846",
"0.54442495",
"0.52739334",
"0.52726233",
"0.52140445",
"0.5201265",
"0.51955277",
"0.51929265",
"0.5155476",
"0.5134872",
"0.5134046",
"0.5119188",
"0.51171273",
"0.50842667",
"0.5080774",
"0.50633264",
"0.5032284",
"0.50321996",
"0.501... | 0.55938125 | 1 |
converting the Temporal and Causal Reasoning (TCR) dataset. we only convert the CLinks (causal relations) from this dataset | def convert_tcr(self):
def read_text(file_name, event_a_id, event_b_id):
idx_val = {"span1": [], "span2": [], "signal": []}
parsed_doc = minidom.parse(self.dir_path + "tcr/TemporalPart/{}".format(file_name))
elements = parsed_doc.getElementsByTagName('TEXT')
text... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_because(self):\n\n nlp = spacy.load(\"en_core_web_sm\")\n\n mismatch = 0\n\n # for NYT and PTB LDC subscription is needed to get access to the raw text.\n folders = [\"CongressionalHearings\", \"MASC\"]\n folders_path = self.dir_path + \"because/\"\n\n data = p... | [
"0.602957",
"0.6015742",
"0.5534727",
"0.5479699",
"0.5443935",
"0.5395257",
"0.52790487",
"0.5232999",
"0.52184343",
"0.5194403",
"0.51874876",
"0.51455873",
"0.5137188",
"0.51324403",
"0.5116074",
"0.50823003",
"0.5079268",
"0.50704724",
"0.50399274",
"0.502988",
"0.5019073... | 0.6667982 | 0 |
checking if spans/signal indexes are correctly stored | def check_span_indexes(row, print_mismatch=False):
span1 = ""
span2 = ""
signal = ""
try:
for arg in row["idx"]["span1"]:
span1 += row["context"][arg[0]:arg[1]] + " "
for arg in row["idx"]["span2"]:
span2 += row["context"][arg[0]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _assert_ks_postformat(self):\n if type(self.idxs) in [list, np.ndarray]:\n if self.ks is None:\n if self.staticneighs:\n pass\n else:\n self.ks = range(len(self.idxs))\n if self.staticneighs:\n pass\... | [
"0.6133162",
"0.6077813",
"0.60676473",
"0.60440373",
"0.5853729",
"0.58372134",
"0.5751763",
"0.56467783",
"0.56202626",
"0.56070673",
"0.560327",
"0.55480796",
"0.5535746",
"0.55251867",
"0.5513032",
"0.54997754",
"0.5485576",
"0.5455791",
"0.5454489",
"0.5447733",
"0.54469... | 0.6880554 | 0 |
Method that posts users article ratings | def post(self, request, slug):
rating = request.data.get("rate", {})
serializer = self.serializer_class(data=rating)
serializer.is_valid(raise_exception=True)
rating = serializer.data.get('rating')
try:
article = Article.objects.get(slug=slug)
except Article.D... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_rating():\n\n id = request.args.get('id')\n\n rating = request.args.get('rating')\n\n record = mod.provide_rating(id, int(rating))\n\n return jsonify(record)",
"def test_successful_article_rate(self):\n ratings_count = ArticleRating.objects.count()\n response = self.client.post... | [
"0.6645988",
"0.6387931",
"0.6326645",
"0.6285556",
"0.6234651",
"0.6205579",
"0.6202724",
"0.61991143",
"0.61464334",
"0.6128219",
"0.6112212",
"0.6095747",
"0.60847276",
"0.6058718",
"0.60537523",
"0.60537523",
"0.60275584",
"0.6013369",
"0.60026664",
"0.5969271",
"0.596924... | 0.7679986 | 0 |
Recusively creates a flattened copy of this node with minimized number of levels of descendants. | def flattened(self) -> 'Node':
# Find attributes that need to be passed to __init__
init_sig = inspect.signature(self.__class__.__init__)
args = []
kwargs = {}
for name, param in init_sig.parameters.items():
if name != 'self':
if param.kind == param.P... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten(self):\n if self.cardinality() == 1:\n return flatten(self._children[0])\n else:\n self._children = [flatten(x) for x in self._children]\n return self",
"def flatten(self, deep=False):\n return _(_flatten(self._, deep))",
"def flatten(self):\r\n... | [
"0.72458404",
"0.6619128",
"0.65220076",
"0.64944136",
"0.639391",
"0.6197897",
"0.6126411",
"0.6029811",
"0.5919103",
"0.5911043",
"0.5883053",
"0.58771634",
"0.5868996",
"0.58539283",
"0.5852626",
"0.58525646",
"0.5851816",
"0.58472955",
"0.5834206",
"0.5832784",
"0.5827587... | 0.69437194 | 1 |
Tries to match the leftover tokens in the given match against the syntax of this node. The passed match is mutated for this purpose results are appended, score is incremented, etc. and tokens are removed off the start of the list. | def match(self, match: CallMatch, matcher: CallMatcher):
if match.terminated:
raise SyntaxError(f"Tried matching {self.node_name} after match was terminated") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scan(self):\n try:\n assert self.text_to_match\n except AssertionError:\n print('Please introduce an operation to calculate.')\n exit(1)\n\n for line in self.text_to_match: # taking each line from the code to match\n i = 0\n while i <... | [
"0.6172225",
"0.601842",
"0.5937306",
"0.5823572",
"0.579332",
"0.5724731",
"0.5639269",
"0.5617338",
"0.5487435",
"0.5473434",
"0.534992",
"0.53473926",
"0.534263",
"0.5342572",
"0.5338044",
"0.5293676",
"0.52836883",
"0.52665645",
"0.52509177",
"0.52274626",
"0.5177186",
... | 0.61094576 | 1 |
Iterate over lines from a given file object, additionally notifying about timeouts while waiting for another line. Timeout is reset after any successful read, not only complete new line. If callback is provided, it will be called on each timeout with the current buffer as a parameter. Otherwise the TIMEOUT object will ... | def readlines(open_file, timeout, callback=None, read_size=8*1024,
keepends=False):
empty_buffer = b"" if "b" in open_file.mode else ""
line_end = b"\n"[0] if "b" in open_file.mode else "\n"
buffer = empty_buffer
# put fd in nonblocking mode
orig_mode = fcntl.fcntl(open_file, fcntl.F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timed_readline(self, f, timeout):\n set_file_nonblock(f)\n\n output = []\n inactive = 0\n while 1:\n (rlist, dummy_wlist, dummy_xlist) = select.select(\n [f], [], [], 1.0)\n\n if not rlist:\n inactive += 1 # approx -- py select do... | [
"0.61119777",
"0.5896191",
"0.560322",
"0.5428448",
"0.5399684",
"0.5296787",
"0.5296469",
"0.52658373",
"0.5175337",
"0.517314",
"0.51211435",
"0.51003283",
"0.5087141",
"0.50569725",
"0.5035388",
"0.49857652",
"0.4959928",
"0.4880364",
"0.48582914",
"0.48462448",
"0.4815448... | 0.74556303 | 0 |
Returns App Interface Settings and raises err if none are found | def get_app_interface_vault_settings(
query_func: Optional[Callable] = None,
) -> AppInterfaceSettingsV1:
if not query_func:
query_func = gql.get_api().query
data = query(query_func=query_func)
if data.vault_settings and len(data.vault_settings) == 1:
return data.vault_settings[0]
ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_app_settings(self, app_id: str) -> dict:\r\n return await self.get(API_APP_SETTINGS.format(app_id=app_id))",
"def ApisPluginSettings():\r\n s = QSettings()\r\n if s.contains(\"APIS/config_ini\"):\r\n if os.path.isfile(s.value(\"APIS/config_ini\")):\r\n return IsApisIn... | [
"0.6039296",
"0.6015567",
"0.5801867",
"0.57970756",
"0.57541674",
"0.5720897",
"0.5720897",
"0.5712615",
"0.5649527",
"0.56003296",
"0.55904794",
"0.55358535",
"0.5534301",
"0.54528487",
"0.5449227",
"0.541584",
"0.53999346",
"0.53855485",
"0.5381734",
"0.53525096",
"0.53337... | 0.622705 | 0 |
Ensure the AwstatsDateTime object is returned | def test_14_digit_datetime_detection(self):
obj = awstats_reader.awstats_datetime('20091130165230')
self.assertTrue(isinstance(obj, awstats_reader.AwstatsDateTime)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_8_digit_date_detection(self):\n obj = awstats_reader.awstats_datetime('20091130')\n self.assertTrue(isinstance(obj, awstats_reader.AwstatsDate))",
"def test_good_year_datetime_output(self):\n obj = awstats_reader.awstats_datetime('20110430184200')\n self.assertEqual(obj.strft... | [
"0.66076154",
"0.6488521",
"0.6446941",
"0.63618976",
"0.62729996",
"0.61813337",
"0.61061424",
"0.60447544",
"0.6028732",
"0.59466094",
"0.5929499",
"0.5929499",
"0.5929499",
"0.59210616",
"0.5810795",
"0.5778264",
"0.57757336",
"0.5775328",
"0.5775328",
"0.5775328",
"0.5733... | 0.6918935 | 0 |
Ensure the AwstatsDate object is returned | def test_8_digit_date_detection(self):
obj = awstats_reader.awstats_datetime('20091130')
self.assertTrue(isinstance(obj, awstats_reader.AwstatsDate)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_8_digit_date(self):\n obj = awstats_reader.awstats_datetime('20091130')\n dt = datetime.date(2009, 11, 30)\n self.assertEqual(obj, dt)",
"def test_14_digit_datetime_detection(self):\n obj = awstats_reader.awstats_datetime('20091130165230')\n self.assertTrue(isinstance(... | [
"0.6437812",
"0.63024503",
"0.62427574",
"0.62113756",
"0.59866077",
"0.59665716",
"0.5926878",
"0.59001034",
"0.58730924",
"0.5848526",
"0.5835353",
"0.5803044",
"0.57739955",
"0.5763104",
"0.57546425",
"0.57519275",
"0.5748616",
"0.5731963",
"0.57292914",
"0.57015216",
"0.5... | 0.6940124 | 0 |
Ensure the Awstats 'year zero' is parsed correctly | def test_year_year_zero_datetime_parse(self):
obj = awstats_reader.awstats_datetime('0')
self.assertEqual(obj,datetime.datetime(1,1,1)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_valid_year(self):\n ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n obj = ar[2009]\n self.assertTrue(isinstance(obj, awstats_reader.AwstatsYear))",
"def test_year_zero_datetime_output(self):\n obj = awstats_reader.awstats_datetime('0')\n self.assertEqua... | [
"0.70513827",
"0.68340546",
"0.66232955",
"0.6615311",
"0.65585643",
"0.6353769",
"0.62322736",
"0.6222804",
"0.6211978",
"0.61747843",
"0.6174546",
"0.6132883",
"0.60056454",
"0.59914804",
"0.59635276",
"0.5883222",
"0.5855215",
"0.5854856",
"0.5850049",
"0.58355856",
"0.578... | 0.722813 | 0 |
Ensure the Awstats 'year zero' is printed correctly | def test_year_zero_datetime_output(self):
obj = awstats_reader.awstats_datetime('0')
self.assertEqual(obj.strftime('%Y%m%d%H%M%S'), '0') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_contains_year_false(self):\n ary = self.ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n self.assertFalse(2111 in ary)",
"def test_valid_year(self):\n ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n obj = ar[2009]\n self.assertTrue(isinst... | [
"0.66403437",
"0.6536451",
"0.63753825",
"0.62673664",
"0.6207401",
"0.61917317",
"0.6154529",
"0.6110436",
"0.6105024",
"0.5963014",
"0.5932915",
"0.5905722",
"0.58687806",
"0.58364046",
"0.58119833",
"0.580732",
"0.57936305",
"0.578511",
"0.57611996",
"0.5717137",
"0.568780... | 0.72177917 | 0 |
Ensure an invalid date/time string raises an exception | def test_datetime_invalid_string(self):
self.assertRaises(RuntimeError, awstats_reader.awstats_datetime, '2009') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_parseTimeInvalidValues(self):\n invalidStrings = [\n \"invalid-July-2017\",\n \"2-invalid-2017\",\n \"2-July-invalid\",\n ]\n for invalid in invalidStrings:\n self.assertRaises(ValueError, imap4.parseTime, invalid)",
"def check_for_date(da... | [
"0.75215286",
"0.7407858",
"0.73107445",
"0.730337",
"0.72772247",
"0.72475946",
"0.72064584",
"0.7192523",
"0.71754783",
"0.7161565",
"0.7098979",
"0.70989174",
"0.7084737",
"0.70051914",
"0.6986578",
"0.6953829",
"0.6947387",
"0.6934257",
"0.69293207",
"0.6887574",
"0.68865... | 0.7970865 | 0 |
Ensure AttrDict behaves correctly | def test_attr_dict(self):
obj = awstats_reader.AttrDict([('this','that'), ('thus','those')])
self.assertEqual(obj.thus, 'those') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, *args, **kwargs):\n super(AttrDict, self).__init__(*args, **kwargs)\n self.__dict__ = self",
"def _attrdict_copy(d):\n if isinstance(d, collections.Iterable):\n return AttrDict(dict(d))\n else:\n return AttrDict(vars(d))",
"def test_AttrDict():\n obj1 = A... | [
"0.7354787",
"0.72906035",
"0.7020043",
"0.669473",
"0.6610493",
"0.65496176",
"0.65444803",
"0.65163445",
"0.6481328",
"0.6431096",
"0.6423854",
"0.6423775",
"0.64009047",
"0.6381526",
"0.6378648",
"0.63614047",
"0.63610876",
"0.6355034",
"0.6340104",
"0.63372",
"0.6318897",... | 0.7784895 | 0 |
Ensure getting a valid year returns an AwstatsYear object | def test_valid_year(self):
ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')
obj = ar[2009]
self.assertTrue(isinstance(obj, awstats_reader.AwstatsYear)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_convert_date_to_year(self):\n # TODO there might be a more robust way to write this with try except statements.",
"def validate_issue_year(issue_year: str) -> None:\n if not 2010 <= int(issue_year) <= 2020:\n raise ValueError(\"Issue year is outside permissible range\")",
"def get_yea... | [
"0.73922276",
"0.72166854",
"0.6916472",
"0.68877065",
"0.68712634",
"0.6859881",
"0.68143725",
"0.68008727",
"0.67789584",
"0.67338055",
"0.67268026",
"0.67057836",
"0.6645676",
"0.66393757",
"0.6607056",
"0.6599604",
"0.6587792",
"0.65776736",
"0.6574135",
"0.6541188",
"0.6... | 0.8441673 | 0 |
Ensure passing an invalid directory raises an exception | def test_invalid_dir(self):
self.assertRaises(OSError, awstats_reader.AwstatsReader, '/tmp/XYZ', 'example.com') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_valid_dir_raises():\n with pytest.raises(ValueError):\n assert cli._valid_dir(__file__)",
"def testNotADirectory(self):\n\n self.assertRaises(OSError,\n parse_package,\n \"not_a_directory\")",
"def validate(self):\n if n... | [
"0.80748916",
"0.7542145",
"0.7516036",
"0.7433864",
"0.72304064",
"0.72137",
"0.72002786",
"0.7110699",
"0.70915544",
"0.7086711",
"0.70566595",
"0.7036449",
"0.70118964",
"0.69912297",
"0.6910922",
"0.6893493",
"0.6856812",
"0.68513775",
"0.68485045",
"0.6835844",
"0.682576... | 0.75636476 | 1 |
Ensure AwstatsYear's __iter__ function is working | def test_iter_operation(self):
ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')
year_iter = ar.__iter__()
self.assertTrue(isinstance(year_iter, types.GeneratorType)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_iter_all_years(self):\n ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n self.assertEqual([ary.year for ary in ar], [2008,2009])",
"def __iter__():",
"def __iter__():",
"def __iter__():",
"def __iter__():",
"def __iter__(self):\n return self._timeseriesData.__... | [
"0.747938",
"0.6764943",
"0.6764943",
"0.6764943",
"0.6764943",
"0.6622207",
"0.6540972",
"0.65393555",
"0.65393555",
"0.65393555",
"0.65393555",
"0.65393555",
"0.65361863",
"0.65303284",
"0.65303284",
"0.65303284",
"0.65303284",
"0.65303284",
"0.65303284",
"0.65303284",
"0.6... | 0.80881435 | 0 |
Ensure all years were found | def test_found_all_years(self):
ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')
self.assertEqual(ar.years, [2008,2009]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_iter_all_years(self):\n ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n self.assertEqual([ary.year for ary in ar], [2008,2009])",
"def test_contains_year_true(self):\n ary = self.ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n self.assertTrue(2... | [
"0.725118",
"0.6920845",
"0.68317854",
"0.6637079",
"0.6544854",
"0.6469519",
"0.6464729",
"0.6458883",
"0.64579237",
"0.64038175",
"0.64022326",
"0.6389562",
"0.63483584",
"0.632103",
"0.6318852",
"0.63097703",
"0.63036245",
"0.6300243",
"0.62268406",
"0.62212217",
"0.621370... | 0.75650537 | 0 |
Ensure year iterator is working | def test_iter_all_years(self):
ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')
self.assertEqual([ary.year for ary in ar], [2008,2009]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_valid_year(self):\n ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')\n obj = ar[2009]\n self.assertTrue(isinstance(obj, awstats_reader.AwstatsYear))",
"def test_convert_date_to_year(self):\n # TODO there might be a more robust way to write this with try except st... | [
"0.74485046",
"0.722017",
"0.7159253",
"0.71416354",
"0.7115227",
"0.70655686",
"0.69642186",
"0.69211155",
"0.689775",
"0.68808764",
"0.68312097",
"0.6820379",
"0.67323714",
"0.6730003",
"0.6689766",
"0.66819614",
"0.6604337",
"0.6573597",
"0.65593755",
"0.6433794",
"0.64226... | 0.76609194 | 0 |
Ensure AwstatsReader __str__ is operating correctly | def test_str(self):
ar = awstats_reader.AwstatsReader(test_file_dir, 'jjncj.com')
self.assertEqual(str(ar), '<AwstatsReader: 2008, 2009>') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self) -> str:\n return str(self.getvalue())",
"def __str__(self) -> str:\n return str(self.getvalue())",
"def __str__(self) -> str:\n return str(self.getvalue())",
"def __str__(self):\n raise RuntimeError(\"Needs to be implemented in base class\")",
"def __str__(self... | [
"0.6440056",
"0.6440056",
"0.6440056",
"0.63903576",
"0.6384944",
"0.63043535",
"0.62657744",
"0.6204816",
"0.6204816",
"0.6204816",
"0.6204816",
"0.6173845",
"0.6162936",
"0.61604625",
"0.61604625",
"0.6145091",
"0.6141328",
"0.6127298",
"0.61086106",
"0.6101893",
"0.6045484... | 0.7224496 | 0 |
Ensure getting a valid month returns an AwstatsMonth object | def test_valid_month(self):
ar_month = self.ar[2009][11]
self.assertTrue(isinstance(ar_month, awstats_reader.AwstatsMonth)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_month():\n return handle_invalid_inputs(question_3, months)",
"def test_invalid_month_orig(self):\n year, month, error = clean_year_month(2014, 3, 13)\n self.assertEqual(year, 2014)\n self.assertEqual(month, timezone.localtime(timezone.now()).month)\n self.assertEqual(error... | [
"0.7399216",
"0.7066788",
"0.6701171",
"0.64644045",
"0.6434533",
"0.6400915",
"0.63761866",
"0.6372643",
"0.6372203",
"0.6311716",
"0.6311716",
"0.629667",
"0.6244824",
"0.62216574",
"0.6219935",
"0.6195043",
"0.6185525",
"0.618388",
"0.6168952",
"0.6123335",
"0.6102531",
... | 0.81634337 | 0 |
Ensure all months were found | def test_found_all_months(self):
ary = self.ar[2009]
self.assertEqual(ary.months, [11,12]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_iter_all_months(self):\n ary = self.ar[2009]\n self.assertEqual([arm.month for arm in ary], [11,12])",
"def test_all_valid_months(self):\n\n for expected, month in enumerate(range(1, 12), 2):\n actual = self.expander.get_next_month(month)\n self.assertEqual(exp... | [
"0.7435198",
"0.741321",
"0.72674966",
"0.66813445",
"0.66769683",
"0.66602445",
"0.6584554",
"0.65477747",
"0.65444785",
"0.6527775",
"0.6511594",
"0.6503141",
"0.63049865",
"0.6303601",
"0.6270493",
"0.62528765",
"0.6175067",
"0.6160518",
"0.61507237",
"0.6081394",
"0.60449... | 0.7632666 | 0 |
Ensure getting an invalid sections raises an exception | def test_get_invalid_section(self):
arm = self.ar[2009][11]
self.assertRaises(KeyError, arm.__getitem__, 'invalid_section') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_invalid_line(self):\n ars = self.ar[2009][11]['general']\n self.assertRaises(KeyError, ars.__getitem__, 'invalid_section')",
"def test_invalid_section(api):\n\n\twith pytest.raises(top_stories.InvalidSectionType):\n\t\tapi.get_stories(\"work\")",
"def test_get_valid_section(self):\n ... | [
"0.7639965",
"0.7530015",
"0.6645535",
"0.64013624",
"0.63592637",
"0.6352041",
"0.63428366",
"0.633529",
"0.628922",
"0.6257539",
"0.62238103",
"0.6187944",
"0.61851245",
"0.61795425",
"0.61621684",
"0.6097364",
"0.60905343",
"0.6073719",
"0.6062952",
"0.60604334",
"0.597859... | 0.7766114 | 0 |
Ensure getting an valid section resturns an AwstatsSection object | def test_get_valid_section(self):
arm = self.ar[2009][11]
ars = arm['general']
self.assertTrue(isinstance(ars, awstats_reader.AwstatsSection)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_section_is_correct(self):\n res = self.client().post('/api/v1/sections/', headers={'Content-Type': 'application/json'},\n data=json.dumps(self.section))\n get_res = self.client().get('api/v1/sections/', headers={'Content-Type': 'application/json'})\n reco... | [
"0.64830524",
"0.6437649",
"0.6403535",
"0.61213636",
"0.60362893",
"0.5934413",
"0.59340304",
"0.59030515",
"0.5847053",
"0.5834436",
"0.58115435",
"0.57783747",
"0.57330745",
"0.57293683",
"0.57261056",
"0.5721001",
"0.56782395",
"0.5660851",
"0.5641199",
"0.5614902",
"0.56... | 0.797956 | 0 |
Ensure AwstatsMonth __str__ is operating correctly | def test_str(self):
arm = self.ar[2009][11]
self.assertEqual(str(arm), '<AwstatsMonth 2009-11>') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return \"{}/{}/{}\".format(self.days, self.month, self.year)",
"def __str__(self):\n return '%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s ' % (self.Month,\n self.Production,self.Hygienist_Production,\n ... | [
"0.64234143",
"0.6405669",
"0.6312703",
"0.6152072",
"0.6088585",
"0.6074719",
"0.6066167",
"0.6056576",
"0.6045593",
"0.5912124",
"0.58773804",
"0.58773804",
"0.5874149",
"0.58628887",
"0.5851416",
"0.5835767",
"0.5835767",
"0.57914853",
"0.5768759",
"0.5749073",
"0.5746679"... | 0.70271933 | 0 |
Ensure the section iterator works | def test_section_iterator(self):
ars = self.ar[2009][11]['general']
self.assertEqual(list(ars), self.__class__.wanted_lines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n return self.iter_sections()",
"def __getitem__(self, section_id):",
"def testSectionCount(self):\n\n self.sectionCount(3640)",
"def get_sections(self, unsafe = False):\n sect_size = self.obj_vm.profile.get_obj_size(\"_IMAGE_SECTION_HEADER\")\n start_addr = se... | [
"0.65837616",
"0.63715476",
"0.63501054",
"0.6170457",
"0.6158147",
"0.6063117",
"0.5993213",
"0.5986937",
"0.59361935",
"0.59278345",
"0.5820033",
"0.577187",
"0.57642907",
"0.575868",
"0.5756754",
"0.5725268",
"0.56497675",
"0.56069064",
"0.5582588",
"0.55313957",
"0.551495... | 0.7266804 | 0 |
Ensure the section keys works | def test_section_keys(self):
ars = self.ar[2009][11]['general']
self.assertEqual(ars.keys(), self.__class__.wanted_lines) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_keys(self):",
"def _check_scenario_sections_valid(self):\n # 0. check correct number of keys\n assert len(self.yaml_dict) >= len(VALID_CONFIG_KEYS), \\\n (f\"Too few config file keys: {len(self.yaml_dict)} \"\n f\"< {len(VALID_CONFIG_KEYS)}\")\n\n # 1. check ... | [
"0.6966411",
"0.6636832",
"0.63369906",
"0.6268932",
"0.61439484",
"0.6120949",
"0.61201805",
"0.60759425",
"0.59677076",
"0.59380287",
"0.5931355",
"0.59227556",
"0.5892664",
"0.58917904",
"0.58907425",
"0.58798087",
"0.58576727",
"0.5829641",
"0.5819116",
"0.5815514",
"0.58... | 0.7518866 | 0 |
Ensure sort_info() returns the correct value | def test_get_sort_info(self):
ars = self.ar[2009][11]['day']
self.assertEqual(ars.get_sort_info(), (31, 'key', True)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sortby(self):\n ...",
"def data_for_sorting() -> NoReturn:\n raise NotImplementedError",
"def data_for_sorting() -> NoReturn:\n raise NotImplementedError",
"def sort():\n return -1",
"def sort_key(self):\n ...",
"def sort_results(self):\n pass",
"def test_calc_sort... | [
"0.6887864",
"0.67729044",
"0.67729044",
"0.663876",
"0.639614",
"0.6391474",
"0.63133466",
"0.6295025",
"0.6286599",
"0.6271265",
"0.6271265",
"0.62489593",
"0.6147179",
"0.6127028",
"0.6124141",
"0.61035395",
"0.5958654",
"0.5947068",
"0.5931625",
"0.59231436",
"0.59040993"... | 0.7176486 | 0 |
Test max merge operation | def test_merge_max(self):
ars = self.ar[2009][11]['general']
ars2 = awstats_reader.AwstatsReader(test_file_dir,
'joshuakugler.com')[2009][11]['general']
self.assertEqual(ars.merge(ars2, 'LastLine', 'line'), 1011585) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def maximum_inplace(a, b):",
"def merge_max_value(old, new):\n assert isinstance(old, list) and isinstance(new, list)\n if old != []:\n assert len(old) == len(new)\n for i in range(len(old)):\n assert type(old[i]) == type(new[i])\n if isinstance(old[i], list):\n ... | [
"0.6275006",
"0.593724",
"0.5911999",
"0.58882487",
"0.5831045",
"0.5742898",
"0.5721348",
"0.5717068",
"0.5683367",
"0.5680305",
"0.5678709",
"0.5666629",
"0.56514305",
"0.56473863",
"0.56473863",
"0.56473446",
"0.5646442",
"0.563833",
"0.56252265",
"0.56242645",
"0.5592913"... | 0.7708226 | 0 |
Test min merge operation | def test_merge_min(self):
ars = self.ar[2009][11]['general']
ars2 = awstats_reader.AwstatsReader(test_file_dir,
'joshuakugler.com')[2009][11]['general']
self.assertEqual(ars.merge(ars2, 'FirstTime', 'first_time'),
awstats_reade... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_merge(self):\n A = [1,4,6,7,8,2,3,4,5,7]\n p = 0\n q = 5\n r = 10\n A_merged = mst.merge(A, p, q, r)\n expected = [1, 2, 3, 4, 4, 5, 6, 7, 7, 8] \n self.assertEqual(A, A_merged)",
"def test_merge_one():\n run_merge([2], [1], [1, 2])",
"def test_merge... | [
"0.6608233",
"0.65667146",
"0.6261121",
"0.62599766",
"0.6255003",
"0.62359107",
"0.619222",
"0.61421436",
"0.6088124",
"0.59750324",
"0.5946483",
"0.58967537",
"0.58788097",
"0.58637404",
"0.5842563",
"0.5834824",
"0.582716",
"0.576548",
"0.5761729",
"0.5728254",
"0.5693495"... | 0.7452321 | 0 |
Test sum merge operation | def test_merge_sum(self):
ars = self.ar[2009][11]['general']
ars2 = awstats_reader.AwstatsReader(test_file_dir,
'joshuakugler.com')[2009][11]['general']
self.assertEqual(ars.merge(ars2, 'LastUpdate', 'parsed'), 1262637) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_merge_two_two_same():\n run_merge([1, 3], [1, 3], [1, 1, 3, 3])",
"def test_merge_one():\n run_merge([2], [1], [1, 2])",
"def test_merge_two_two():\n run_merge([1, 3], [2, 4], [1, 2, 3, 4])",
"def test_merge(self):\n A = [1,4,6,7,8,2,3,4,5,7]\n p = 0\n q = 5\n r ... | [
"0.7141497",
"0.7100413",
"0.6905584",
"0.67995965",
"0.6671649",
"0.6599154",
"0.6361683",
"0.62766",
"0.6258748",
"0.62534034",
"0.6243685",
"0.62164307",
"0.6154805",
"0.6142858",
"0.6073334",
"0.6050744",
"0.6046231",
"0.5917821",
"0.5910872",
"0.5878969",
"0.5817445",
... | 0.78561425 | 0 |
Test 'latest' merge operation | def test_merge_latest(self):
ars = self.ar[2009][11]['sider_404']
ars2 = awstats_reader.AwstatsReader(test_file_dir,
'joshuakugler.com')[2009][11]['sider_404']
self.assertEqual(ars.merge(ars2, '/styles/widgets/blog-widget.css',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_merge_one():\n run_merge([2], [1], [1, 2])",
"def test_merge_two_two():\n run_merge([1, 3], [2, 4], [1, 2, 3, 4])",
"def test_merge_repl(self):\n ars = self.ar[2009][11]['general']\n ars2 = awstats_reader.AwstatsReader(test_file_dir,\n 'jo... | [
"0.69885623",
"0.6757757",
"0.6753691",
"0.6658166",
"0.65769815",
"0.6525068",
"0.65248036",
"0.64669645",
"0.63832617",
"0.636778",
"0.6341219",
"0.63130605",
"0.6295262",
"0.62648433",
"0.62196106",
"0.6164196",
"0.6116738",
"0.60876983",
"0.6076365",
"0.60210365",
"0.5993... | 0.724473 | 0 |
Cleanly run a command function from a controller. Returns a tuple of (result_dict, output_txt). | def run_controller_command(namespace, func, cli_opts=None, cli_args=None,
*args, **kw):
# set configurations per what is passed at cli
for nam in namespaces:
set_config_opts_per_cli_opts(nam, cli_opts)
controller = namespaces[namespace].controller(cli_opts, cli_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _process_command(self, **kwargs):\n return self.run_command(**kwargs)",
"def run_controller(puzzle, commands, filename=''):\n out = StringIO('')\n sys.stdout = out\n sys.stdin = StringIO('\\n'.join(commands))\n Controller(puzzle)\n r = out.getvalue()\n out.close()\n sys.stdin = sy... | [
"0.60094017",
"0.60047543",
"0.5916209",
"0.57260597",
"0.5647986",
"0.55900633",
"0.558507",
"0.55588293",
"0.55456895",
"0.552593",
"0.55257577",
"0.54946244",
"0.5489593",
"0.54423314",
"0.54417825",
"0.5425991",
"0.5421396",
"0.54150647",
"0.5402691",
"0.53899765",
"0.538... | 0.64815605 | 0 |
Check if user is course staff. | def is_course_staff(self):
# pylint: disable=no-member
return getattr(self.xmodule_runtime, 'user_is_staff', False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_staff(self):\n # Simplest possible answer: All admins are staff\n return self.is_admin",
"def is_staff(self):\n # Simplest possible answer: All admins are staff\n return self.is_admin",
"def is_staff(self):\n # Simplest possible answer: All admins are staff\n re... | [
"0.7812888",
"0.7812888",
"0.7812888",
"0.77043736",
"0.75808585",
"0.74982476",
"0.74982476",
"0.74835616",
"0.7433671",
"0.7433608",
"0.7419011",
"0.7370185",
"0.7277466",
"0.7176093",
"0.7100349",
"0.70355904",
"0.69785076",
"0.6971723",
"0.69194937",
"0.68560183",
"0.6839... | 0.8251043 | 1 |
Check if user role is instructor. | def is_instructor(self):
# pylint: disable=no-member
return self.xmodule_runtime.get_user_role() == 'instructor' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_instructor(self):\n return bool(LTI_ROLES[INSTRUCTOR] & self.roles)",
"def test_user_role_instructor(self):\r\n self.assertEqual(\r\n 'instructor',\r\n access.get_user_role(self.course_instructor, self.course_key)\r\n )\r\n # Masquerade instructor\r\n ... | [
"0.8229154",
"0.80855906",
"0.76690066",
"0.743809",
"0.6934937",
"0.68856174",
"0.68823963",
"0.68345535",
"0.6777783",
"0.67101526",
"0.6564345",
"0.651139",
"0.6504513",
"0.64901537",
"0.6472167",
"0.64069164",
"0.63845605",
"0.63611573",
"0.6316969",
"0.63070035",
"0.6298... | 0.8304061 | 0 |
Return true if in studio. | def is_in_studio(self):
return getattr(self.xmodule_runtime, 'is_author_mode', False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_devel(self):\r\n\r\n return self.is_debug()",
"def is_developer_mode() -> bool:\n return False if os.getenv(\"SQLTASK_DEVELOPER_MODE\") is None else True",
"def in_studio_preview(self):\n # When we're running in Studio Preview mode, the XBlock won't provide us with a user ID.\n #... | [
"0.6649628",
"0.6432166",
"0.63258266",
"0.62225497",
"0.6192834",
"0.61168176",
"0.6112861",
"0.6061566",
"0.6058878",
"0.6051578",
"0.6026513",
"0.60143167",
"0.6001241",
"0.6000642",
"0.5966863",
"0.59390026",
"0.5921607",
"0.5904243",
"0.58977544",
"0.58624846",
"0.585796... | 0.6814753 | 0 |
The primary view of the KVXBlock, shown to students when viewing courses. | def student_view(self, context=None):
self.updateStudentVideoUrls()
context = {
'not_in_studio': not self.is_in_studio(),
'display_name': self.display_name,
'video_kulu_id': none_to_empty(self.video_kulu_id),
'video_mp4_url': none_to_empty(self.video_mp4_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view(self) -> str:\n return pulumi.get(self, \"view\")",
"def get_view(self):\n return self.view",
"def View(self):\n return self._view",
"def GetView(self):\r\n return self.model.GetView()",
"def student_view(self, context):\r\n # When rendering a Studio preview, ren... | [
"0.61220413",
"0.59718084",
"0.5966654",
"0.5919892",
"0.5843645",
"0.58410907",
"0.5831091",
"0.582094",
"0.5797516",
"0.57385707",
"0.56423795",
"0.55864364",
"0.5515048",
"0.54937017",
"0.5461392",
"0.54511243",
"0.5451026",
"0.544862",
"0.5430297",
"0.53909093",
"0.538732... | 0.6088232 | 1 |
Return fragment for editing block in studio. | def studio_view(self, context=None):
try:
cls = type(self)
edit_fields = (
(field, type, none_to_empty(getattr(self, field.name)), validator)
for field, type, validator in (
(cls.display_name, 'String', 'string'),
(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def studio_view(self, context):\n html_str = pkg_resources.resource_string(\n __name__, \"static/html/oppia_edit.html\")\n oppiaid = self.oppiaid or ''\n frag = Fragment(unicode(html_str).format(\n oppiaid=oppiaid, src=self.src, width=self.width,\n height=self.... | [
"0.6956461",
"0.65164703",
"0.6471651",
"0.64604455",
"0.6316834",
"0.6315888",
"0.60998046",
"0.60868067",
"0.60628337",
"0.59412",
"0.59274775",
"0.5921215",
"0.5897774",
"0.58977467",
"0.5882051",
"0.58485204",
"0.5809552",
"0.5797233",
"0.5786303",
"0.5786303",
"0.5772003... | 0.70899147 | 0 |
Set the video url and thumbnail url from Kulu Valley. We first call a KV api to get the mp4/hls url. Calling with 'kulu_id' = '' deletes existing video. | def set_video_id(self, data, suffix=''):
kulu_id = data['kulu_id']
def studentVideoData():
return {
'video_mp4_url': none_to_empty(self.video_mp4_url),
'video_hls_url': none_to_empty(self.video_hls_url),
'video_thumbnail_url': self.video_thumb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_video_urls(self, kulu_id, retry=True):\n mp4_url = None\n hls_url = None\n if (kulu_id):\n def fetch_kulu_urls(kulu_id):\n mp4_url = None\n hls_url = None\n kulu_valley_kulus_url = \"https://imd.kuluvalley.com/api/2.1/rest/kulus/\... | [
"0.6160896",
"0.6141144",
"0.5943396",
"0.59220606",
"0.587498",
"0.5847446",
"0.57661587",
"0.5741027",
"0.5693852",
"0.5692398",
"0.56496",
"0.5589736",
"0.5558275",
"0.54962265",
"0.5485665",
"0.54696524",
"0.54669696",
"0.5452187",
"0.54437584",
"0.5406843",
"0.5399361",
... | 0.6809097 | 0 |
Call KV api to get mp4/hls urls. | def get_video_urls(self, kulu_id, retry=True):
mp4_url = None
hls_url = None
if (kulu_id):
def fetch_kulu_urls(kulu_id):
mp4_url = None
hls_url = None
kulu_valley_kulus_url = "https://imd.kuluvalley.com/api/2.1/rest/kulus/"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_video(path):\r\n #logger.info(\"######: {}, log: {}########\".format('rk8', path))\r\n #original=https://api.hotstar.com/h/v1/play?contentId=1000238814\r\n #path=\"https://api.hotstar.com/h/v2/play/in/contents/1000238814\"\r\n # Create a playable item with a path to play.\r\n data = make_re... | [
"0.59782803",
"0.5949858",
"0.57822216",
"0.57652056",
"0.5762113",
"0.56082535",
"0.55757767",
"0.55116516",
"0.5491569",
"0.5449194",
"0.5448186",
"0.543254",
"0.54281485",
"0.54059446",
"0.53967017",
"0.53914803",
"0.5379635",
"0.5362169",
"0.53378993",
"0.5317494",
"0.529... | 0.6270511 | 0 |
Mark the assignment as not done for a this student. | def mark_as_not_done(self):
grade_event = {'value': 0, 'max_value': self.points}
self.runtime.publish(self, 'grade', grade_event) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deny(self):\n self.quest_node['completed_by'] = ''\n self.completed_by = None\n self.active = True\n self.quest_node['active'] = True\n graph.push(self.quest_node)",
"def status_assignee_reset(self):\n self.assigned_to = None\n self.status = 'new'\n sel... | [
"0.62643397",
"0.5935697",
"0.5818681",
"0.5786964",
"0.5711947",
"0.5705716",
"0.56888163",
"0.56069565",
"0.56069565",
"0.56069565",
"0.56069565",
"0.56069565",
"0.55722106",
"0.5409544",
"0.5389403",
"0.5377383",
"0.5372755",
"0.5360463",
"0.53570914",
"0.53020144",
"0.527... | 0.69058186 | 0 |
Evaluate a template by resource path, applying the provided context. | def render_template(template_path, context=None): # pragma: NO COVER
if context is None:
context = {}
template_str = load_resource(template_path)
template = Template(template_str)
return template.render(Context(context)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render_template(self, template_path, context={}):\n template_str = self.load_resource(template_path)\n return Template(template_str).render(Context(context))",
"def render_template(self, template_path, context = {}):\n template_str = self.load_resource(template_path)\n return Temp... | [
"0.6798284",
"0.67674947",
"0.6560511",
"0.6547902",
"0.6547902",
"0.63448447",
"0.62632746",
"0.62598234",
"0.61450964",
"0.61317617",
"0.61253536",
"0.6089809",
"0.6079951",
"0.59087443",
"0.58783853",
"0.5824385",
"0.5804045",
"0.57722825",
"0.57717615",
"0.5769329",
"0.57... | 0.7218898 | 1 |
Get current date and time in UTC. | def nowUTC():
return datetime.datetime.now(pytz.utc) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_utc_now():\n return datetime.datetime.utcnow().replace(tzinfo=pytz.timezone(\"UTC\"))",
"def currentUTC():\n return str(datetime.utcnow())",
"def utc_now():\n return datetime.now(tz=timezone.utc)",
"def now_utc() -> datetime:\n return datetime.now(timezone.utc)",
"def utc_now():\n real... | [
"0.7977052",
"0.7973361",
"0.79039377",
"0.7867884",
"0.7760147",
"0.7717462",
"0.76961374",
"0.7683743",
"0.75971127",
"0.75816166",
"0.75357926",
"0.75291264",
"0.75291264",
"0.75020146",
"0.7498298",
"0.7488854",
"0.74866146",
"0.742559",
"0.74225163",
"0.7386496",
"0.7383... | 0.8204733 | 0 |
Upload all completed analyses | def upload_all_completed_analyses(context: click.Context, pipeline: Pipeline = None):
LOG.info("----------------- AUTO -----------------")
status_db: Store = context.obj.status_db
exit_code = 0
for analysis_obj in status_db.get_analyses_to_upload(pipeline=pipeline):
if analysis_obj.family.ana... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nipt_upload_all(context: click.Context, dry_run: bool):\n\n LOG.info(\"*** UPLOAD ALL AVAILABLE NIPT RESULTS ***\")\n\n nipt_upload_api = NiptUploadAPI(context.obj)\n analyses = nipt_upload_api.get_all_upload_analyses()\n if not analyses:\n LOG.info(\"No analyses found for upload\")\n ... | [
"0.6465152",
"0.6398682",
"0.6212569",
"0.6039674",
"0.6018058",
"0.59461796",
"0.59346527",
"0.5898499",
"0.5893549",
"0.58733207",
"0.58722526",
"0.581383",
"0.57783085",
"0.5756504",
"0.57188946",
"0.5670503",
"0.5642734",
"0.56356883",
"0.56247014",
"0.558974",
"0.5582261... | 0.76476234 | 0 |
Initiate OpenAI envirenment and pygame interface with a given game name | def init_gym_pygame(game_name):
# OpenAI gym setup
game_name = 'gvgai-aliens-lvl0-v0'
env = gym.make(game_name)
env.reset()
# pygame setup
pg.init()
height = env.observation_space.shape[0]
width = env.observation_space.shape[1]
screen = pg.display.set_mode((width, height))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_game(self):",
"def start_game(self):\n\n\t\tpass",
"def main():\n\n name, game = select_game(vgc.KNOWN_GAMES)\n print('---- Launching: %s -----'%name)\n game.game.main()\n sys.exit(0)",
"def init_new_game(self):\n self.game = get_new_game(self.game_config)",
"def game_initializ... | [
"0.6829018",
"0.673299",
"0.66179657",
"0.6537415",
"0.6471707",
"0.6461702",
"0.6298109",
"0.62840134",
"0.62181157",
"0.6211808",
"0.62098134",
"0.6166325",
"0.61149716",
"0.6112158",
"0.60812247",
"0.6063152",
"0.600286",
"0.5999461",
"0.5974559",
"0.59493476",
"0.59344417... | 0.7436073 | 0 |
Get all morpheme language model resources. | def index(self):
try:
query = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel))
query = h.add_order_by(query, dict(request.GET), self.query_builder)
return h.add_pagination(query, dict(request.GET))
except Invalid, e:
response.statu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_languages():\n\tdef _get():\n\t\tif not frappe.db:\n\t\t\tfrappe.connect()\n\t\treturn frappe.db.sql_list('select name from tabLanguage')\n\treturn frappe.cache().get_value('languages', _get)",
"def show(self, id):\n lm = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel)... | [
"0.60161203",
"0.6002696",
"0.5761688",
"0.5719073",
"0.5714151",
"0.5669752",
"0.5650922",
"0.56342536",
"0.5534222",
"0.55096865",
"0.55061066",
"0.5499107",
"0.5476339",
"0.547446",
"0.54663837",
"0.5464759",
"0.5463116",
"0.5457306",
"0.54516536",
"0.5441719",
"0.5433335"... | 0.6047643 | 0 |
Create a new morpheme language model resource and return it. | def create(self):
try:
schema = MorphemeLanguageModelSchema()
values = json.loads(unicode(request.body, request.charset))
data = schema.to_python(values)
lm = create_new_morpheme_language_model(data)
Session.add(lm)
Session.commit()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_new_morpheme_language_model(data):\n morpheme_language_model = MorphemeLanguageModel(\n parent_directory = h.get_OLD_directory_path('morphemelanguagemodels', config=config),\n rare_delimiter = h.rare_delimiter,\n start_symbol = h.lm_start,\n end_symbol = h.lm_end,\n ... | [
"0.8325517",
"0.6794504",
"0.5871044",
"0.57733005",
"0.5680156",
"0.56658226",
"0.56055146",
"0.54730964",
"0.5311173",
"0.5311173",
"0.52688736",
"0.51949227",
"0.5186271",
"0.5113376",
"0.50966656",
"0.5090427",
"0.50744426",
"0.5067211",
"0.50491345",
"0.5048742",
"0.5011... | 0.8410151 | 0 |
Update a morpheme language model and return it. | def update(self, id):
morpheme_language_model = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel)).get(int(id))
if morpheme_language_model:
try:
schema = MorphemeLanguageModelSchema()
values = json.loads(unicode(request.body, request.cha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_morpheme_language_model(morpheme_language_model, data):\n changed = False\n changed = morpheme_language_model.set_attr('name', h.normalize(data['name']), changed)\n changed = morpheme_language_model.set_attr('description', h.normalize(data['description']), changed)\n changed = morpheme_langu... | [
"0.8106362",
"0.66909057",
"0.6051896",
"0.58790237",
"0.55874133",
"0.55796665",
"0.55562264",
"0.55158925",
"0.528301",
"0.52645445",
"0.51916885",
"0.5145453",
"0.5043197",
"0.50045",
"0.4970845",
"0.49497432",
"0.49354246",
"0.49251613",
"0.49052346",
"0.48986137",
"0.488... | 0.71658677 | 1 |
Delete an existing morpheme language model and return it. | def delete(self, id):
lm = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel)).get(id)
if lm:
lm_dict = lm.get_dict()
backup_morpheme_language_model(lm_dict)
Session.delete(lm)
Session.commit()
lm.remove_directory()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n self.parser.add_argument('lp_id',\n help=\"Language pack id\")\n args = self.parser.parse_args()\n self.client.languagepacks.delete(lp_id=args.lp_id)",
"def delete_model(self):\n os.remove(self.filepath)\n self.cmodel = None",... | [
"0.6155966",
"0.6002906",
"0.5728056",
"0.5722994",
"0.57034665",
"0.5685019",
"0.5675561",
"0.56174475",
"0.5606163",
"0.5569662",
"0.5522245",
"0.5454257",
"0.5435363",
"0.5431152",
"0.53872836",
"0.53638625",
"0.5357778",
"0.53532773",
"0.5330724",
"0.53241915",
"0.5322878... | 0.83754015 | 0 |
Return the morpheme language model with ``morpheme_language_model.id==id`` and its previous versions. | def history(self, id):
lm, previous_versions = h.get_model_and_previous_versions('MorphemeLanguageModel', id)
if lm or previous_versions:
return {'morpheme_language_model': lm,
'previous_versions': previous_versions}
else:
response.status_int = 404
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show(self, id):\n lm = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel)).get(id)\n if lm:\n return lm\n else:\n response.status_int = 404\n return {'error': 'There is no morpheme language model with id %s' % id}",
"def delete(self,... | [
"0.6415808",
"0.6097",
"0.6039022",
"0.59486246",
"0.5881677",
"0.5697839",
"0.56362563",
"0.55430144",
"0.53850615",
"0.5303731",
"0.5047375",
"0.50460297",
"0.5034118",
"0.49749365",
"0.4957252",
"0.48968148",
"0.48657927",
"0.48402837",
"0.4839967",
"0.48372543",
"0.481847... | 0.7944097 | 0 |
Serve the generated ARPA file of the morpheme language model. | def serve_arpa(self, id):
lm = Session.query(MorphemeLanguageModel).get(id)
if lm:
arpa_path = lm.get_file_path('arpa')
if os.path.isfile(arpa_path):
if authorized_to_access_arpa_file(session['user'], lm):
return forward(FileApp(arpa_path, cont... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_mo(app, request, filename):\n \n filename = secure_filename(filename)\n file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)\n \n if file_exists(file_path):\n try:\n po = polib.pofile(file_path)\n except:\n flash('Invalid translation file d... | [
"0.5006395",
"0.50015306",
"0.49433556",
"0.49287143",
"0.49164858",
"0.49064565",
"0.49038222",
"0.48439574",
"0.48380062",
"0.4832627",
"0.48288256",
"0.48258945",
"0.48111463",
"0.4804801",
"0.4794179",
"0.4748777",
"0.47469828",
"0.47468007",
"0.47346982",
"0.47157112",
"... | 0.7436431 | 0 |
Return True if user is authorized to access the ARPA file of the morpheme LM. | def authorized_to_access_arpa_file(user, morpheme_language_model):
if (morpheme_language_model.restricted and user.role != u'administrator' and
user not in h.get_unrestricted_users()):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_anon_engine(self):\n if (self.config['anonymization'] and self.config['anonymization']['enabled']):\n # Anonymization enabled\n # Ensure that RSNA DICOM Anonymizer is found\n if not os.path.isfile('./DicomAnonymizerTool/DAT.jar'):\n questions = [\n ... | [
"0.6275402",
"0.5793569",
"0.57907313",
"0.5722351",
"0.56709385",
"0.56661177",
"0.5656761",
"0.5624764",
"0.55805975",
"0.5576716",
"0.5551308",
"0.5513037",
"0.5511215",
"0.5505518",
"0.54963565",
"0.54761",
"0.5475294",
"0.54663765",
"0.5452673",
"0.54511124",
"0.54192686... | 0.7826882 | 0 |
Backup a morpheme language model. | def backup_morpheme_language_model(morpheme_language_model_dict):
morpheme_language_model_backup = MorphemeLanguageModelBackup()
morpheme_language_model_backup.vivify(morpheme_language_model_dict)
Session.add(morpheme_language_model_backup) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backup(self):\n self.logger.info(\"Backing up current version of model...\")\n self.save_checkpoint(filename='backup.pth.tar')",
"def save_backup(\n self):\n self.backup = self.data",
"def update_morpheme_language_model(morpheme_language_model, data):\n changed = False\n c... | [
"0.5779697",
"0.5633495",
"0.5630774",
"0.55966496",
"0.5410926",
"0.53896815",
"0.5368427",
"0.5291819",
"0.52788013",
"0.5235104",
"0.51721776",
"0.5145846",
"0.511987",
"0.5064891",
"0.5033217",
"0.49739802",
"0.49671623",
"0.49500835",
"0.49490598",
"0.4948198",
"0.493843... | 0.74086803 | 0 |
Create a new morpheme language model. | def create_new_morpheme_language_model(data):
morpheme_language_model = MorphemeLanguageModel(
parent_directory = h.get_OLD_directory_path('morphemelanguagemodels', config=config),
rare_delimiter = h.rare_delimiter,
start_symbol = h.lm_start,
end_symbol = h.lm_end,
morpheme_d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self):\n try:\n schema = MorphemeLanguageModelSchema()\n values = json.loads(unicode(request.body, request.charset))\n data = schema.to_python(values)\n lm = create_new_morpheme_language_model(data)\n Session.add(lm)\n Session.comm... | [
"0.7630027",
"0.6253416",
"0.5871046",
"0.57203037",
"0.56235754",
"0.5558559",
"0.554392",
"0.5423824",
"0.5318251",
"0.5288623",
"0.5206004",
"0.504",
"0.50267416",
"0.5023903",
"0.5018694",
"0.5009188",
"0.50068223",
"0.49928263",
"0.4980367",
"0.49777767",
"0.49690226",
... | 0.84771603 | 0 |
Update a morpheme language model. | def update_morpheme_language_model(morpheme_language_model, data):
changed = False
changed = morpheme_language_model.set_attr('name', h.normalize(data['name']), changed)
changed = morpheme_language_model.set_attr('description', h.normalize(data['description']), changed)
changed = morpheme_language_model... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, id):\n morpheme_language_model = h.eagerload_morpheme_language_model(Session.query(MorphemeLanguageModel)).get(int(id))\n if morpheme_language_model:\n try:\n schema = MorphemeLanguageModelSchema()\n values = json.loads(unicode(request.body, r... | [
"0.6590283",
"0.61649984",
"0.6020707",
"0.5370134",
"0.5319907",
"0.5260949",
"0.5187935",
"0.51856285",
"0.5172407",
"0.5169884",
"0.51690274",
"0.5159293",
"0.5152756",
"0.5090267",
"0.50899065",
"0.49365464",
"0.4918349",
"0.4915732",
"0.49082556",
"0.48996368",
"0.487529... | 0.8199087 | 0 |
Tests that the HTTP communicator class works at a basic level. | async def test_http_communicator():
communicator = HttpCommunicator(SimpleHttpApp(), "GET", "/test/?foo=bar")
response = await communicator.get_response()
assert response["body"] == b"test response"
assert response["status"] == 200 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_orchestrator_http_simple(self):\n pass",
"def test_http_request(self):\n\n response = requests.get(self.live_server_url)\n assert response.status_code == 200",
"def test_connection():\n response = echo_client(\"GET webroot/sample.txt HTTP/1.1\")\n print response\n assert ... | [
"0.7461062",
"0.68259627",
"0.6795011",
"0.6644746",
"0.65877044",
"0.6434576",
"0.6307624",
"0.62547976",
"0.62244654",
"0.6132937",
"0.6116299",
"0.6108578",
"0.6099518",
"0.6088262",
"0.6055557",
"0.6054001",
"0.6027249",
"0.6020124",
"0.6006208",
"0.5996886",
"0.5986765",... | 0.7764261 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.