Datasets:
Dataset Viewer
task_id
int64 19.3k
41.9M
| prompt
stringlengths 17
68
| suffix
stringlengths 0
22
| canonical_solution
stringlengths 6
153
| test_start
stringlengths 22
198
| test
sequence | entry_point
stringlengths 7
10
| intent
stringlengths 19
200
| library
sequence |
|---|---|---|---|---|---|---|---|---|
3,283,984 |
def f_3283984():
return
|
bytes.fromhex('4a4b4c').decode('utf-8')
|
def check(candidate):
|
[
"\n assert candidate() == \"JKL\"\n"
] |
f_3283984
|
decode a hex string '4a4b4c' to UTF-8.
|
[] |
|
3,844,801 |
def f_3844801(myList):
return
|
all(x == myList[0] for x in myList)
|
def check(candidate):
|
[
"\n assert candidate([1,2,3]) == False\n",
"\n assert candidate([1,1,1,1,1,1]) == True\n",
"\n assert candidate([1]) == True\n",
"\n assert candidate(['k','k','k','k','k']) == True\n",
"\n assert candidate([None,'%$#ga',3]) == False\n"
] |
f_3844801
|
check if all elements in list `myList` are identical
|
[] |
|
4,302,166 |
def f_4302166():
return
|
'%*s : %*s' % (20, 'Python', 20, 'Very Good')
|
def check(candidate):
|
[
"\n assert candidate() == ' Python : Very Good'\n"
] |
f_4302166
|
format number of spaces between strings `Python`, `:` and `Very Good` to be `20`
|
[] |
|
7,555,335 |
def f_7555335(d):
return
|
d.decode('cp1251').encode('utf8')
|
def check(candidate):
|
[
"\n assert candidate('hello world!'.encode('cp1251')) == b'hello world!'\n",
"\n assert candidate('%*(^O*'.encode('cp1251')) == b'%*(^O*'\n",
"\n assert candidate(''.encode('cp1251')) == b''\n",
"\n assert candidate('hello world!'.encode('cp1251')) != 'hello world!'\n"
] |
f_7555335
|
convert a string `d` from CP-1251 to UTF-8
|
[] |
|
2,544,710 |
def f_2544710(kwargs):
return
|
{k: v for k, v in list(kwargs.items()) if v is not None}
|
def check(candidate):
|
[
"\n assert candidate({i: None for i in range(10)}) == {}\n",
"\n assert candidate({i: min(i,4) for i in range(6)}) == {0:0,1:1,2:2,3:3,4:4,5:4}\n",
"\n assert candidate({'abc': 'abc'})['abc'] == 'abc'\n",
"\n assert candidate({'x': None, 'yy': 234}) == {'yy': 234}\n"
] |
f_2544710
|
get rid of None values in dictionary `kwargs`
|
[] |
|
2,544,710 |
def f_2544710(kwargs):
return
|
dict((k, v) for k, v in kwargs.items() if v is not None)
|
def check(candidate):
|
[
"\n assert candidate({i: None for i in range(10)}) == {}\n",
"\n assert candidate({i: min(i,4) for i in range(6)}) == {0:0,1:1,2:2,3:3,4:4,5:4}\n",
"\n assert candidate({'abc': 'abc'})['abc'] == 'abc'\n",
"\n assert candidate({'x': None, 'yy': 234}) == {'yy': 234}\n"
] |
f_2544710
|
get rid of None values in dictionary `kwargs`
|
[] |
|
14,971,373 |
def f_14971373():
return
|
subprocess.check_output('ps -ef | grep something | wc -l', shell=True)
|
import subprocess
from unittest.mock import Mock
def check(candidate):
|
[
"\n output = b' PID TTY TIME CMD\\n 226 pts/1 00:00:00 bash\\n 285 pts/1 00:00:00 python3\\n 352 pts/1 00:00:00 ps\\n'\n subprocess.check_output = Mock(return_value = output)\n assert candidate() == output\n"
] |
f_14971373
|
capture final output of a chain of system commands `ps -ef | grep something | wc -l`
|
[
"subprocess"
] |
|
6,726,636 |
def f_6726636():
return
|
"""""".join(['a', 'b', 'c'])
|
def check(candidate):
|
[
"\n assert candidate() == \"abc\"\n",
"\n assert candidate() == 'a' + 'b' + 'c'\n"
] |
f_6726636
|
concatenate a list of strings `['a', 'b', 'c']`
|
[] |
|
18,079,563 |
def f_18079563(s1, s2):
return
|
pd.Series(list(set(s1).intersection(set(s2))))
|
import pandas as pd
def check(candidate):
|
[
"\n x1, x2 = pd.Series([1,2]), pd.Series([1,3])\n assert candidate(x1, x2).equals(pd.Series([1]))\n",
"\n x1, x2 = pd.Series([1,2]), pd.Series([1,3, 10, 4, 5, 9])\n assert candidate(x1, x2).equals(pd.Series([1]))\n",
"\n x1, x2 = pd.Series([1,2]), pd.Series([1,2, 10])\n assert candidate(x1, x2).equals(pd.Series([1, 2]))\n"
] |
f_18079563
|
find intersection data between series `s1` and series `s2`
|
[
"pandas"
] |
|
8,315,209 |
def f_8315209(client):
|
return
|
client.send('HTTP/1.0 200 OK\r\n')
|
import socket
from unittest.mock import Mock
import mock
def check(candidate):
|
[
"\n with mock.patch('socket.socket') as mock_socket:\n mock_socket.return_value.recv.return_value = ''\n mock_socket.bind(('', 8080))\n mock_socket.listen(5)\n mock_socket.accept = Mock(return_value = mock_socket)\n mock_socket.send = Mock()\n try:\n candidate(mock_socket)\n except:\n assert False\n"
] |
f_8315209
|
sending http headers to `client`
|
[
"socket"
] |
26,153,795 |
def f_26153795(when):
return
|
datetime.datetime.strptime(when, '%Y-%m-%d').date()
|
import datetime
def check(candidate):
|
[
"\n assert candidate('2013-05-07') == datetime.date(2013, 5, 7)\n",
"\n assert candidate('2000-02-29') == datetime.date(2000, 2, 29)\n",
"\n assert candidate('1990-01-08') == datetime.date(1990, 1, 8)\n",
"\n assert candidate('1990-1-08') == datetime.date(1990, 1, 8)\n",
"\n assert candidate('1990-1-8') == datetime.date(1990, 1, 8)\n",
"\n assert candidate('1990-01-8') == datetime.date(1990, 1, 8)\n"
] |
f_26153795
|
Format a datetime string `when` to extract date only
|
[
"datetime"
] |
|
172,439 |
def f_172439(inputString):
return
|
inputString.split('\n')
|
def check(candidate):
|
[
"\n assert candidate('line a\\nfollows by line b\t...bye\\n') == ['line a', 'follows by line b\t...bye', '']\n",
"\n assert candidate('no new line in this sentence. ') == ['no new line in this sentence. ']\n",
"\n assert candidate('a\tbfs hhhdf\tsfdas') == ['a\tbfs hhhdf\tsfdas']\n",
"\n assert candidate('') == ['']\n"
] |
f_172439
|
split a multi-line string `inputString` into separate strings
|
[] |
|
172,439 |
def f_172439():
return
|
' a \n b \r\n c '.split('\n')
|
def check(candidate):
|
[
"\n assert candidate() == [' a ', ' b \\r', ' c ']\n"
] |
f_172439
|
Split a multi-line string ` a \n b \r\n c ` by new line character `\n`
|
[] |
|
13,954,222 |
def f_13954222(b):
return
|
""":""".join(str(x) for x in b)
|
def check(candidate):
|
[
"\n assert candidate(['x','y','zzz']) == 'x:y:zzz'\n",
"\n assert candidate(['111','22','3']) == '111:22:3'\n",
"\n assert candidate(['']) == ''\n",
"\n assert candidate([':',':']) == ':::'\n",
"\n assert candidate([',','#','#$%']) == ',:#:#$%'\n",
"\n assert candidate(['a','b','c']) != 'abc'\n"
] |
f_13954222
|
concatenate elements of list `b` by a colon ":"
|
[] |
|
13,567,345 |
def f_13567345(a):
return
|
a.sum(axis=1)
|
import numpy as np
def check(candidate):
|
[
"\n a1 = np.array([[i for i in range(3)] for j in range(5)])\n assert np.array_equal(candidate(a1), np.array([3, 3, 3, 3, 3]))\n",
"\n a2 = np.array([[i+j for i in range(3)] for j in range(5)])\n assert np.array_equal(candidate(a2), np.array([ 3, 6, 9, 12, 15]))\n",
"\n a3 = np.array([[i*j for i in range(3)] for j in range(5)])\n assert np.array_equal(candidate(a3), np.array([ 0, 3, 6, 9, 12]))\n"
] |
f_13567345
|
Calculate sum over all rows of 2D numpy array `a`
|
[
"numpy"
] |
|
29,784,889 |
def f_29784889():
|
return
|
warnings.simplefilter('always')
|
import warnings
def check(candidate):
|
[
"\n candidate() \n assert any([(wf[0] == 'always') for wf in warnings.filters])\n"
] |
f_29784889
|
enable warnings using action 'always'
|
[
"warnings"
] |
13,550,423 |
def f_13550423(l):
return
|
' '.join(map(str, l))
|
def check(candidate):
|
[
"\n assert candidate(['x','y','zzz']) == 'x y zzz'\n",
"\n assert candidate(['111','22','3']) == '111 22 3'\n",
"\n assert candidate(['']) == ''\n",
"\n assert candidate([':',':']) == ': :'\n",
"\n assert candidate([',','#','#$%']) == ', # #$%'\n",
"\n assert candidate(['a','b','c']) != 'abc'\n"
] |
f_13550423
|
concatenate items of list `l` with a space ' '
|
[] |
|
698,223 |
def f_698223():
return
|
time.strptime('30/03/09 16:31:32.123', '%d/%m/%y %H:%M:%S.%f')
|
import time
def check(candidate):
|
[
"\n answer = time.strptime('30/03/09 16:31:32.123', '%d/%m/%y %H:%M:%S.%f')\n assert candidate() == answer\n false_1 = time.strptime('30/03/09 17:31:32.123', '%d/%m/%y %H:%M:%S.%f')\n assert candidate() != false_1\n false_2 = time.strptime('20/03/09 17:31:32.123', '%d/%m/%y %H:%M:%S.%f')\n assert candidate() != false_2\n"
] |
f_698223
|
parse a time string '30/03/09 16:31:32.123' containing milliseconds in it
|
[
"time"
] |
|
6,633,523 |
def f_6633523(my_string):
|
return my_float
|
my_float = float(my_string.replace(',', ''))
|
def check(candidate):
|
[
"\n assert (candidate('1,234.00') - 1234.0) < 1e-6\n",
"\n assert (candidate('0.00') - 0.00) < 1e-6\n",
"\n assert (candidate('1,000,000.00') - 1000000.00) < 1e-6\n",
"\n assert (candidate('1,000,000.00') - 999999.98) > 1e-6\n",
"\n assert (candidate('1') - 1.00) < 1e-6\n"
] |
f_6633523
|
convert a string `my_string` with dot and comma into a float number `my_float`
|
[] |
6,633,523 |
def f_6633523():
return
|
float('123,456.908'.replace(',', ''))
|
def check(candidate):
|
[
"\n assert (candidate() - 123456.908) < 1e-6\n assert (candidate() - 123456.9) > 1e-6\n assert (candidate() - 1234.908) > 1e-6\n assert type(candidate()) == float\n assert int(candidate()) == 123456\n"
] |
f_6633523
|
convert a string `123,456.908` with dot and comma into a floating number
|
[] |
|
3,108,285 |
def f_3108285():
|
return
|
sys.path.append('/path/to/whatever')
|
import sys
def check(candidate):
|
[
"\n original_paths = [sp for sp in sys.path]\n candidate()\n assert '/path/to/whatever' in sys.path\n"
] |
f_3108285
|
set python path '/path/to/whatever' in python script
|
[
"sys"
] |
2,195,340 |
def f_2195340():
return
|
re.split('(\\W+)', 'Words, words, words.')
|
import re
def check(candidate):
|
[
"\n assert candidate() == ['Words', ', ', 'words', ', ', 'words', '.', '']\n assert candidate() == ['Words', ', '] + ['words', ', ', 'words', '.', '']\n"
] |
f_2195340
|
split string 'Words, words, words.' using a regex '(\\W+)'
|
[
"re"
] |
|
17,977,584 |
def f_17977584():
return
|
open('Output.txt', 'a')
|
def check(candidate):
|
[
"\n f = candidate()\n assert str(f.__class__) == \"<class '_io.TextIOWrapper'>\"\n assert f.name == 'Output.txt'\n assert f.mode == 'a'\n"
] |
f_17977584
|
open a file `Output.txt` in append mode
|
[] |
|
22,676 |
def f_22676():
return
|
urllib.request.urlretrieve('https://github.com/zorazrw/multilingual-conala/blob/master/dataset/test/es_test.json', 'mp3.mp3')
|
import urllib
def check(candidate):
|
[
"\n results = candidate()\n assert len(results) == 2\n assert results[0] == \"mp3.mp3\"\n assert results[1].values()[0] == \"GitHub.com\"\n"
] |
f_22676
|
download a file "http://www.example.com/songs/mp3.mp3" over HTTP and save to "mp3.mp3"
|
[
"urllib"
] |
|
22,676 |
def f_22676(url):
|
return html
|
html = urllib.request.urlopen(url).read()
|
import urllib
def check(candidate):
|
[
"\n html = candidate(\"https://github.com/zorazrw/multilingual-conala/blob/master/dataset/test/es_test.json\")\n assert b\"zorazrw/multilingual-conala\" in html\n"
] |
f_22676
|
download a file 'http://www.example.com/' over HTTP
|
[
"urllib"
] |
22,676 |
def f_22676(url):
return
|
requests.get(url)
|
import requests
def check(candidate):
|
[
"\n assert candidate(\"https://github.com/\").url == \"https://github.com/\"\n",
"\n assert candidate(\"https://google.com/\").url == \"https://www.google.com/\"\n"
] |
f_22676
|
download a file `url` over HTTP
|
[
"requests"
] |
|
22,676 |
def f_22676(url):
|
return
|
response = requests.get(url, stream=True)
with open('10MB', 'wb') as handle:
for data in response.iter_content():
handle.write(data)
|
import requests
def check(candidate):
|
[
"\n candidate(\"https://github.com/\")\n with open(\"10MB\", 'rb') as fr: \n all_data = [data for data in fr]\n assert all_data[: 2] == [b'\\n', b'\\n']\n"
] |
f_22676
|
download a file `url` over HTTP and save to "10MB"
|
[
"requests"
] |
15,405,636 |
def f_15405636(parser):
return
|
parser.add_argument('--version', action='version', version='%(prog)s 2.0')
|
import argparse
def check(candidate):
|
[
"\n parser = argparse.ArgumentParser()\n output = candidate(parser)\n assert output.option_strings == ['--version']\n assert output.dest == 'version'\n assert output.nargs == 0\n"
] |
f_15405636
|
argparse add argument with flag '--version' and version action of '%(prog)s 2.0' to parser `parser`
|
[
"argparse"
] |
|
17,665,809 |
def f_17665809(d):
return
|
{i: d[i] for i in d if i != 'c'}
|
def check(candidate):
|
[
"\n assert candidate({'a': 1 , 'b': 2, 'c': 3}) == {'a': 1 , 'b': 2}\n",
"\n assert candidate({'c': None}) == {}\n",
"\n assert candidate({'a': 1 , 'b': 2, 'c': 3}) != {'a': 1 , 'b': 2, 'c': 3}\n",
"\n assert candidate({'c': 1, 'cc': 2, 'ccc':3}) == {'cc': 2, 'ccc':3}\n",
"\n assert 'c' not in candidate({'c':i for i in range(10)})\n"
] |
f_17665809
|
remove key 'c' from dictionary `d`
|
[] |
|
41,861,705 |
def f_41861705(split_df, csv_df):
return
|
pd.merge(split_df, csv_df, on=['key'], suffixes=('_left', '_right'))
|
import pandas as pd
def check(candidate):
|
[
"\n split_df = pd.DataFrame({'key': ['foo', 'bar'], 'value': [1, 2]})\n csv_df = pd.DataFrame({'key': ['foo', 'baz'], 'value': [3, 4]})\n result = pd.DataFrame({'key': ['foo'], 'value_left': [1],'value_right': [3]})\n assert all(candidate(csv_df, split_df) == result)\n"
] |
f_41861705
|
Create new DataFrame object by merging columns "key" of dataframes `split_df` and `csv_df` and rename the columns from dataframes `split_df` and `csv_df` with suffix `_left` and `_right` respectively
|
[
"pandas"
] |
|
10,697,757 |
def f_10697757(s):
return
|
s.split(' ', 4)
|
def check(candidate):
|
[
"\n assert candidate('1 0 A10B 100 Description: This is a description with spaces') == ['1', '0', 'A10B', '100', 'Description: This is a description with spaces']\n",
"\n assert candidate('this-is-a-continuous-sequence') == ['this-is-a-continuous-sequence']\n",
"\n assert candidate('') == ['']\n",
"\n assert candidate('\t') == ['\t']\n"
] |
f_10697757
|
Split a string `s` by space with `4` splits
|
[] |
|
16,344,756 |
def f_16344756(app):
return
|
app.run(debug=True)
|
from flask import Flask
from unittest.mock import Mock
def check(candidate):
|
[
"\n Flask = Mock()\n app = Flask('mai')\n try:\n candidate(app)\n except:\n return False\n"
] |
f_16344756
|
enable debug mode on Flask application `app`
|
[
"flask"
] |
|
40,133,826 |
def f_40133826(mylist):
|
return
|
pickle.dump(mylist, open('save.txt', 'wb'))
|
import pickle
def check(candidate):
|
[
"\n candidate([i for i in range(10)])\n data = pickle.load(open('save.txt', 'rb'))\n assert data == [i for i in range(10)]\n",
"\n candidate([\"hello\", \"world\", \"!\"])\n data = pickle.load(open('save.txt', 'rb'))\n assert data == [\"hello\", \"world\", \"!\"]\n"
] |
f_40133826
|
python save list `mylist` to file object 'save.txt'
|
[
"pickle"
] |
4,490,961 |
def f_4490961(P, T):
return
|
scipy.tensordot(P, T, axes=[1, 1]).swapaxes(0, 1)
|
import scipy
import numpy as np
def check(candidate):
|
[
"\n P = np.array([[6, 2, 7], [1, 1, 8], [8, 7, 1], [9, 6, 4], [2, 1, 1]])\n T = np.array([[[9, 7, 2, 3], [9, 6, 8, 2], [6, 6, 2, 8]],\n [[4, 5, 5, 3], [1, 8, 3, 5], [2, 8, 1, 6]]])\n result = np.array([[[114, 96, 42, 78], [ 66, 61, 26, 69], [141, 104, 74, 46], [159, 123, 74, 71], [ 33, 26, 14, 16]], \n [[ 40, 102, 43, 70], [ 21, 77, 16, 56], [ 41, 104, 62, 65], [ 50, 125, 67, 81], [ 11, 26, 14, 17]]])\n assert np.array_equal(candidate(P, T), result)\n"
] |
f_4490961
|
Multiply a matrix `P` with a 3d tensor `T` in scipy
|
[
"numpy",
"scipy"
] |
|
2,173,087 |
def f_2173087():
return
|
numpy.zeros((3, 3, 3))
|
import numpy
import numpy as np
def check(candidate):
|
[
"\n result = np.array([[[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]],\n [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]],\n [[0., 0., 0.], [0., 0., 0.], [0., 0., 0.]]])\n assert np.array_equal(candidate(), result)\n"
] |
f_2173087
|
Create 3d array of zeroes of size `(3,3,3)`
|
[
"numpy"
] |
|
6,266,727 |
def f_6266727(content):
return
|
""" """.join(content.split(' ')[:-1])
|
def check(candidate):
|
[
"\n assert candidate('test') == ''\n",
"\n assert candidate('this is an example content') == 'this is an example'\n",
"\n assert candidate(' ') == ' '\n",
"\n assert candidate('') == ''\n",
"\n assert candidate('blank and tab\t') == 'blank and'\n"
] |
f_6266727
|
cut off the last word of a sentence `content`
|
[] |
|
30,385,151 |
def f_30385151(x):
|
return x
|
x = np.asarray(x).reshape(1, -1)[(0), :]
|
import numpy as np
def check(candidate):
|
[
"\n assert all(candidate(1.) == np.asarray(1.))\n",
"\n assert all(candidate(123) == np.asarray(123))\n",
"\n assert all(candidate('a') == np.asarray('a'))\n",
"\n assert all(candidate(False) == np.asarray(False))\n"
] |
f_30385151
|
convert scalar `x` to array
|
[
"numpy"
] |
15,856,127 |
def f_15856127(L):
return
|
sum(sum(i) if isinstance(i, list) else i for i in L)
|
def check(candidate):
|
[
"\n assert candidate([1,2,3,4]) == 10\n",
"\n assert candidate([[1],[2],[3],[4]]) == 10\n",
"\n assert candidate([1,1,1,1]) == 4\n",
"\n assert candidate([1,[2,3],[4]]) == 10\n",
"\n assert candidate([]) == 0\n",
"\n assert candidate([[], []]) == 0\n"
] |
f_15856127
|
sum all elements of nested list `L`
|
[] |
|
1,592,158 |
def f_1592158():
return
|
struct.unpack('!f', bytes.fromhex('470FC614'))[0]
|
import struct
def check(candidate):
|
[
"\n assert (candidate() - 36806.078125) < 1e-6\n",
"\n assert (candidate() - 32806.079125) > 1e-6\n"
] |
f_1592158
|
convert hex string '470FC614' to a float number
|
[
"struct"
] |
|
5,010,536 |
def f_5010536(my_dict):
|
return my_dict
|
my_dict.update((x, y * 2) for x, y in list(my_dict.items()))
|
def check(candidate):
|
[
"\n assert candidate({'a': [1], 'b': 4.9}) == {'a': [1, 1], 'b': 9.8}\n",
"\n assert candidate({1:1}) == {1:2}\n",
"\n assert candidate({(1,2):[1]}) == {(1,2):[1,1]}\n",
"\n assert candidate({'asd':0}) == {'asd':0}\n",
"\n assert candidate({}) == {}\n"
] |
f_5010536
|
Multiple each value by `2` for all keys in a dictionary `my_dict`
|
[] |
13,745,648 |
def f_13745648():
return
|
subprocess.call('sleep.sh', shell=True)
|
import subprocess
from unittest.mock import Mock
def check(candidate):
|
[
"\n subprocess.call = Mock()\n try:\n candidate()\n except:\n assert False\n"
] |
f_13745648
|
running bash script 'sleep.sh'
|
[
"subprocess"
] |
|
44,778 |
def f_44778(l):
return
|
""",""".join(l)
|
def check(candidate):
|
[
"\n assert candidate(['a','b','c']) == 'a,b,c'\n",
"\n assert candidate(['a','b']) == 'a,b'\n",
"\n assert candidate([',',',',',']) == ',,,,,'\n",
"\n assert candidate([' ',' ','c']) == ' , ,c'\n",
"\n assert candidate([]) == ''\n"
] |
f_44778
|
Join elements of list `l` with a comma `,`
|
[] |
|
44,778 |
def f_44778(myList):
|
return myList
|
myList = ','.join(map(str, myList))
|
def check(candidate):
|
[
"\n assert candidate([1,2,3]) == '1,2,3'\n",
"\n assert candidate([1,2,'a']) == '1,2,a'\n",
"\n assert candidate([]) == ''\n",
"\n assert candidate(['frg',3253]) == 'frg,3253'\n"
] |
f_44778
|
make a comma-separated string from a list `myList`
|
[] |
7,286,365 |
def f_7286365():
return
|
list(reversed(list(range(10))))
|
def check(candidate):
|
[
"\n assert candidate() == [9,8,7,6,5,4,3,2,1,0]\n",
"\n assert len(candidate()) == 10\n",
"\n assert min(candidate()) == 0\n",
"\n assert type(candidate()) == list\n",
"\n assert type(candidate()[-2]) == int\n"
] |
f_7286365
|
reverse the list that contains 1 to 10
|
[] |
|
18,454,570 |
def f_18454570():
return
|
'lamp, bag, mirror'.replace('bag,', '')
|
def check(candidate):
|
[
"\n assert candidate() == 'lamp, mirror'\n assert type(candidate()) == str\n assert len(candidate()) == 13\n assert candidate().startswith('lamp')\n"
] |
f_18454570
|
remove substring 'bag,' from a string 'lamp, bag, mirror'
|
[] |
|
4,357,787 |
def f_4357787(s):
return
|
""".""".join(s.split('.')[::-1])
|
def check(candidate):
|
[
"\n assert candidate('apple.orange.red.green.yellow') == 'yellow.green.red.orange.apple'\n",
"\n assert candidate('apple') == 'apple'\n",
"\n assert candidate('apple.orange') == 'orange.apple'\n",
"\n assert candidate('123.456') == '456.123'\n",
"\n assert candidate('.') == '.'\n"
] |
f_4357787
|
Reverse the order of words, delimited by `.`, in string `s`
|
[] |
|
21,787,496 |
def f_21787496(s):
return
|
datetime.datetime.fromtimestamp(s).strftime('%Y-%m-%d %H:%M:%S.%f')
|
import time
import datetime
def check(candidate):
|
[
"\n assert candidate(1236472) == '1970-01-15 07:27:52.000000'\n",
"\n assert candidate(0) == '1970-01-01 00:00:00.000000'\n",
"\n assert candidate(5.3) == '1970-01-01 00:00:05.300000'\n"
] |
f_21787496
|
convert epoch time represented as milliseconds `s` to string using format '%Y-%m-%d %H:%M:%S.%f'
|
[
"datetime",
"time"
] |
|
21,787,496 |
def f_21787496():
return
|
time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(1236472051807 / 1000.0))
|
import time
def check(candidate):
|
[
"\n assert candidate() == '2009-03-08 00:27:31'\n"
] |
f_21787496
|
parse milliseconds epoch time '1236472051807' to format '%Y-%m-%d %H:%M:%S'
|
[
"time"
] |
|
20,573,459 |
def f_20573459():
return
|
(datetime.datetime.now() - datetime.timedelta(days=7)).date()
|
import datetime
def check(candidate):
|
[
"\n assert datetime.datetime.now().date() - candidate() < datetime.timedelta(days = 7, seconds = 1)\n",
"\n assert datetime.datetime.now().date() - candidate() >= datetime.timedelta(days = 7)\n"
] |
f_20573459
|
get the date 7 days before the current date
|
[
"datetime"
] |
|
15,352,457 |
def f_15352457(column, data):
return
|
sum(row[column] for row in data)
|
def check(candidate):
|
[
"\n assert candidate(1, [[1,2,3], [4,5,6]]) == 7\n",
"\n assert candidate(0, [[1,1,1], [0,1,1]]) == 1\n",
"\n assert candidate(5, [[1,1,1,1,1,2], [0,1,1,1,1,1,1,1,1,1,1]]) == 3\n",
"\n assert candidate(0, [[1],[2],[3],[4]]) == 10\n"
] |
f_15352457
|
sum elements at index `column` of each list in list `data`
|
[] |
|
15,352,457 |
def f_15352457(array):
return
|
[sum(row[i] for row in array) for i in range(len(array[0]))]
|
def check(candidate):
|
[
"\n assert candidate([[1,2,3], [4,5,6]]) == [5, 7, 9]\n",
"\n assert candidate([[1,1,1], [0,1,1]]) == [1, 2, 2]\n",
"\n assert candidate([[1,1,1,1,1,2], [0,1,1,1,1,1,1,1,1,1,1]]) == [1, 2, 2, 2, 2, 3]\n",
"\n assert candidate([[1],[2],[3],[4]]) == [10]\n"
] |
f_15352457
|
sum columns of a list `array`
|
[] |
|
23,164,058 |
def f_23164058():
return
|
base64.b64encode(bytes('your string', 'utf-8'))
|
import base64
def check(candidate):
|
[
"\n assert candidate() == b'eW91ciBzdHJpbmc='\n"
] |
f_23164058
|
encode binary string 'your string' to base64 code
|
[
"base64"
] |
|
11,533,274 |
def f_11533274(dicts):
return
|
dict((k, [d[k] for d in dicts]) for k in dicts[0])
|
def check(candidate):
|
[
"\n assert candidate([{'cat': 1, 'dog': 3}, {'cat' : 2, 'dog': ['happy']}]) == {'cat': [1, 2], 'dog': [3, ['happy']]}\n",
"\n assert candidate([{'cat': 1}, {'cat' : 2}]) != {'cat': 3}\n"
] |
f_11533274
|
combine list of dictionaries `dicts` with the same keys in each list to a single dictionary
|
[] |
|
11,533,274 |
def f_11533274(dicts):
return
|
{k: [d[k] for d in dicts] for k in dicts[0]}
|
def check(candidate):
|
[
"\n assert candidate([{'cat': 1, 'dog': 3}, {'cat' : 2, 'dog': ['happy']}]) == {'cat': [1, 2], 'dog': [3, ['happy']]}\n",
"\n assert candidate([{'cat': 1}, {'cat' : 2}]) != {'cat': 3}\n"
] |
f_11533274
|
Merge a nested dictionary `dicts` into a flat dictionary by concatenating nested values with the same key `k`
|
[] |
|
14,026,704 |
def f_14026704(request):
return
|
request.args['myParam']
|
import multidict
class Request:
def __init__(self, args):
self.args = args
def check(candidate):
|
[
"\n args = multidict.MultiDict([('myParam' , 'popeye')])\n request = Request(args)\n assert candidate(request) == 'popeye'\n"
] |
f_14026704
|
get the url parameter 'myParam' in a Flask view
|
[
"multidict"
] |
|
11,236,006 |
def f_11236006(mylist):
return
|
[k for k, v in list(Counter(mylist).items()) if v > 1]
|
from collections import Counter
def check(candidate):
|
[
"\n assert candidate([1,3,2,2,1,4]) == [1, 2]\n",
"\n assert candidate([1,3,2,2,1,4]) != [3,4]\n",
"\n assert candidate([]) == []\n",
"\n assert candidate([1,1,1,1,1]) == [1]\n",
"\n assert candidate([1.,1.,1.]) == [1.]\n"
] |
f_11236006
|
identify duplicate values in list `mylist`
|
[
"collections"
] |
|
20,211,942 |
def f_20211942(db):
return
|
db.execute("INSERT INTO present VALUES('test2', ?, 10)", (None,))
|
import sqlite3
def check(candidate):
|
[
"\n sqliteConnection = sqlite3.connect('dev.db')\n db = sqliteConnection.cursor()\n print(\"Database created and Successfully Connected to SQLite\")\n db.execute(\"CREATE TABLE present (name VARCHAR(5), age INTEGER, height INTEGER)\")\n try:\n candidate(db)\n except:\n assert False\n"
] |
f_20211942
|
Insert a 'None' value into a SQLite3 table.
|
[
"sqlite3"
] |
|
406,121 |
def f_406121(list_of_menuitems):
return
|
[image for menuitem in list_of_menuitems for image in menuitem]
|
from collections import Counter
def check(candidate):
|
[
"\n assert candidate([[1,2],[3,4,5]]) == [1,2,3,4,5]\n",
"\n assert candidate([[],[]]) == []\n",
"\n assert candidate([[1,1,1], []]) == [1,1,1]\n",
"\n assert candidate([['1'],['2']]) == ['1','2']\n"
] |
f_406121
|
flatten list `list_of_menuitems`
|
[
"collections"
] |
|
4,741,537 |
def f_4741537(a, b):
|
return a
|
a.extend(b)
|
def check(candidate):
|
[
"\n assert candidate([1, 2, 2, 3], {4, 5, 2}) == [1, 2, 2, 3, 2, 4, 5]\n",
"\n assert candidate([], {4,5,2}) == [2,4,5]\n",
"\n assert candidate([1,2,3,4],{2}) == [1,2,3,4,2]\n",
"\n assert candidate([1], {'a'}) == [1, 'a']\n"
] |
f_4741537
|
append elements of a set `b` to a list `a`
|
[] |
15,851,568 |
def f_15851568(x):
return
|
x.rpartition('-')[0]
|
def check(candidate):
|
[
"\n assert candidate('djhajhdjk-dadwqd-dahdjkahsk') == 'djhajhdjk-dadwqd'\n",
"\n assert candidate('/-/') == '/'\n",
"\n assert candidate('---') == '--'\n",
"\n assert candidate('') == ''\n"
] |
f_15851568
|
Split a string `x` by last occurrence of character `-`
|
[] |
|
15,851,568 |
def f_15851568(x):
return
|
x.rsplit('-', 1)[0]
|
def check(candidate):
|
[
"\n assert candidate('2022-03-01') == '2022-03'\n",
"\n assert candidate('2020-2022') == '2020'\n"
] |
f_15851568
|
get the last part of a string before the character '-'
|
[] |
|
17,438,096 |
def f_17438096(filename, ftp):
|
return
|
ftp.storlines('STOR ' + filename, open(filename, 'r'))
|
import ftplib
from unittest.mock import Mock
def check(candidate):
|
[
"\n ftplib.FTP = Mock()\n ftp = ftplib.FTP(\"10.10.10.10\")\n ftp.storlines = Mock()\n file_name = 'readme.txt'\n with open (file_name, 'a') as f:\n f.write('apple')\n candidate(file_name, ftp)\n"
] |
f_17438096
|
upload file using FTP
|
[
"ftplib"
] |
28,742,436 |
def f_28742436():
return
|
np.maximum([2, 3, 4], [1, 5, 2])
|
import numpy as np
def check(candidate):
|
[
"\n assert all(candidate() == np.array([2, 5, 4]))\n"
] |
f_28742436
|
create array containing the maximum value of respective elements of array `[2, 3, 4]` and array `[1, 5, 2]`
|
[
"numpy"
] |
|
34,280,147 |
def f_34280147(l):
return
|
l[3:] + l[:3]
|
def check(candidate):
|
[
"\n assert candidate(\"my-string\") == \"stringmy-\"\n",
"\n assert candidate(\"my \") == \"my \"\n",
"\n assert candidate(\"n;ho0-4w606[q\") == \"o0-4w606[qn;h\"\n"
] |
f_34280147
|
print a list `l` and move first 3 elements to the end of the list
|
[] |
|
4,172,131 |
def f_4172131():
return
|
[int(1000 * random.random()) for i in range(10000)]
|
import random
def check(candidate):
|
[
"\n result = candidate()\n assert isinstance(result, list)\n assert all([isinstance(item, int) for item in result])\n"
] |
f_4172131
|
create a random list of integers
|
[
"random"
] |
|
6,677,332 |
def f_6677332():
return
|
datetime.datetime.now().strftime('%H:%M:%S.%f')
|
import datetime
def check(candidate):
|
[
"\n time_now = datetime.datetime.now().strftime('%H:%M:%S.%f')\n assert candidate().split('.')[0] == time_now.split('.')[0]\n"
] |
f_6677332
|
Using %f with strftime() in Python to get microseconds
|
[
"datetime"
] |
|
15,325,182 |
def f_15325182(df):
return
|
df.b.str.contains('^f')
|
import pandas as pd
def check(candidate):
|
[
"\n df = pd.DataFrame([[1, 'fat'], [2, 'hip'], [3, 'foo']], columns = ['a', 'b'])\n expected = [True, False, True]\n actual = candidate(df)\n for i in range (0, len(expected)):\n assert expected[i] == actual[i]\n"
] |
f_15325182
|
filter rows in pandas starting with alphabet 'f' using regular expression.
|
[
"pandas"
] |
|
583,557 |
def f_583557(tab):
return
|
'\n'.join('\t'.join(str(col) for col in row) for row in tab)
|
def check(candidate):
|
[
"\n assert candidate([[1,2,3],[4,5,6]]) == \"1\\t2\\t3\\n4\\t5\\t6\"\n",
"\n assert candidate([[1, 'x' ,3],[4.4,5,\"six\"]]) == \"1\\tx\\t3\\n4.4\\t5\\tsix\"\n",
"\n assert candidate([]) == \"\"\n",
"\n assert candidate([[],[],[]]) == \"\\n\\n\"\n"
] |
f_583557
|
print a 2 dimensional list `tab` as a table with delimiters
|
[] |
|
38,535,931 |
def f_38535931(df, tuples):
return
|
df.set_index(list('BC')).drop(tuples, errors='ignore').reset_index()
|
import pandas as pd
def check(candidate):
|
[
"\n df = pd.DataFrame([[3, 4], [4, 5], [-1, -2]], columns = ['B', 'C'])\n tuples = [(3, 4), (-1, -2)]\n expected = pd.DataFrame([[4, 5]], columns = ['B', 'C'])\n actual = candidate(df, tuples)\n assert pd.DataFrame.equals(actual, expected)\n"
] |
f_38535931
|
pandas: delete rows in dataframe `df` based on multiple columns values
|
[
"pandas"
] |
|
13,945,749 |
def f_13945749(goals, penalties):
return
|
"""({:d} goals, ${:d})""".format(goals, penalties)
|
def check(candidate):
|
[
"\n assert candidate(0, 0) == \"(0 goals, $0)\"\n",
"\n assert candidate(123, 2) == \"(123 goals, $2)\"\n"
] |
f_13945749
|
format the variables `goals` and `penalties` using string formatting
|
[] |
|
13,945,749 |
def f_13945749(goals, penalties):
return
|
"""({} goals, ${})""".format(goals, penalties)
|
def check(candidate):
|
[
"\n assert candidate(0, 0) == \"(0 goals, $0)\"\n",
"\n assert candidate(123, \"???\") == \"(123 goals, $???)\"\n",
"\n assert candidate(\"x\", 0.0) == \"(x goals, $0.0)\"\n"
] |
f_13945749
|
format string "({} goals, ${})" with variables `goals` and `penalties`
|
[] |
|
18,524,642 |
def f_18524642(L):
return
|
[int(''.join(str(d) for d in x)) for x in L]
|
def check(candidate):
|
[
"\n assert candidate([[1,2], [2,3,4], [1,0,0]]) == [12,234,100]\n",
"\n assert candidate([[1], [2], [3]]) == [1,2,3]\n"
] |
f_18524642
|
convert list of lists `L` to list of integers
|
[] |
|
18,524,642 |
def f_18524642(L):
|
return L
|
L = [int(''.join([str(y) for y in x])) for x in L]
|
def check(candidate):
|
[
"\n assert candidate([[1,2], [2,3,4], [1,0,0]]) == [12,234,100]\n",
"\n assert candidate([[1], [2], [3]]) == [1,2,3]\n",
"\n assert candidate([[1, 0], [0, 2], [3], [0, 0, 0, 0]]) == [10,2,3, 0]\n"
] |
f_18524642
|
convert a list of lists `L` to list of integers
|
[] |
7,138,686 |
def f_7138686(lines, myfile):
|
return
|
myfile.write('\n'.join(lines))
|
def check(candidate):
|
[
"\n with open('tmp.txt', 'w') as myfile:\n candidate([\"first\", \"second\", \"third\"], myfile)\n with open('tmp.txt', 'r') as fr: \n lines = fr.readlines()\n assert lines == [\"first\\n\", \"second\\n\", \"third\"]\n"
] |
f_7138686
|
write the elements of list `lines` concatenated by special character '\n' to file `myfile`
|
[] |
17,238,587 |
def f_17238587(text):
|
return text
|
text = re.sub('\\b(\\w+)( \\1\\b)+', '\\1', text)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"text\") == \"text\"\n",
"\n assert candidate(\"text text\") == \"text\"\n",
"\n assert candidate(\"texttext\") == \"texttext\"\n",
"\n assert candidate(\"text and text\") == \"text and text\"\n"
] |
f_17238587
|
Remove duplicate words from a string `text` using regex
|
[
"re"
] |
26,053,849 |
def f_26053849(df):
return
|
df.astype(bool).sum(axis=1)
|
import pandas as pd
def check(candidate):
|
[
"\n df1 = pd.DataFrame([[0,0,0], [0,1,0], [1,1,1]])\n assert candidate(df1).to_list() == [0, 1, 3]\n",
"\n df2 = pd.DataFrame([[0,0,0], [0,2,0], [1,10,8.9]])\n assert candidate(df1).to_list() == [0, 1, 3]\n",
"\n df2 = pd.DataFrame([[0,0.0,0], [0,2.0,0], [1,10,8.9]])\n assert candidate(df1).to_list() == [0, 1, 3]\n",
"\n df = df = pd.DataFrame([[4, 0, 0], [1, 0, 1]])\n expected = [1, 2]\n actual = candidate(df)\n for i in range(0, len(expected)):\n assert expected[i] == actual[i]\n"
] |
f_26053849
|
count non zero values in each column in pandas data frame `df`
|
[
"pandas"
] |
|
15,534,223 |
def f_15534223():
return
|
re.search('(?<!Distillr)\\\\AcroTray\\.exe', 'C:\\SomeDir\\AcroTray.exe')
|
import re
def check(candidate):
|
[
"\n result = candidate()\n assert result.span() == (10, 23)\n assert result.string == \"C:\\SomeDir\\AcroTray.exe\"\n"
] |
f_15534223
|
search for string that matches regular expression pattern '(?<!Distillr)\\\\AcroTray\\.exe' in string 'C:\\SomeDir\\AcroTray.exe'
|
[
"re"
] |
|
5,453,026 |
def f_5453026():
return
|
"""QH QD JC KD JS""".split()
|
def check(candidate):
|
[
"\n assert candidate() == [\"QH\", \"QD\", \"JC\", \"KD\", \"JS\"]\n"
] |
f_5453026
|
split string 'QH QD JC KD JS' into a list on white spaces
|
[] |
|
18,168,684 |
def f_18168684(line):
return
|
re.search('>.*<', line).group(0)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"hahhdsf>0.0<;sgnd\") == \">0.0<\"\n",
"\n assert candidate(\"hahhdsf>2.34<;xbnfm\") == \">2.34<\"\n"
] |
f_18168684
|
search for occurrences of regex pattern '>.*<' in xml string `line`
|
[
"re"
] |
|
4,914,277 |
def f_4914277(filename):
return
|
open(filename, 'w').close()
|
def check(candidate):
|
[
"\n filename = 'tmp.txt'\n with open(filename, 'w') as fw: fw.write(\"hello world!\")\n with open(filename, 'r') as fr: \n lines = fr.readlines()\n assert len(lines) == 1 and lines[0] == \"hello world!\"\n candidate(filename)\n with open(filename, 'r') as fr: \n lines = fr.readlines()\n assert len(lines) == 0\n"
] |
f_4914277
|
erase all the contents of a file `filename`
|
[] |
|
19,068,269 |
def f_19068269(string_date):
return
|
datetime.datetime.strptime(string_date, '%Y-%m-%d %H:%M:%S.%f')
|
import datetime
def check(candidate):
|
[
"\n assert candidate('2022-10-22 11:59:59.20') == datetime.datetime(2022, 10, 22, 11, 59, 59, 200000)\n",
"\n assert candidate('2000-01-01 11:59:59.20') == datetime.datetime(2000, 1, 1, 11, 59, 59, 200000)\n",
"\n assert candidate('1990-09-09 09:59:59.24') == datetime.datetime(1990, 9, 9, 9, 59, 59, 240000)\n",
"\n d = candidate('2022-12-14 07:06:00.25')\n assert d == datetime.datetime(2022, 12, 14, 7, 6, 0, 250000)\n"
] |
f_19068269
|
convert a string `string_date` into datetime using the format '%Y-%m-%d %H:%M:%S.%f'
|
[
"datetime"
] |
|
20,683,167 |
def f_20683167(thelist):
return
|
[index for index, item in enumerate(thelist) if item[0] == '332']
|
def check(candidate):
|
[
"\n assert candidate([[0,1,2], ['a','bb','ccc'], ['332',33,2], [33,22,332]]) == [2]\n",
"\n assert candidate([[0,1,2], ['332'], ['332'], ['332']]) == [1,2,3]\n",
"\n assert candidate([[0,1,2], [332], [332], [332]]) == []\n"
] |
f_20683167
|
find the index of a list with the first element equal to '332' within the list of lists `thelist`
|
[] |
|
30,693,804 |
def f_30693804(text):
return
|
re.sub('[^\\sa-zA-Z0-9]', '', text).lower().strip()
|
import re
def check(candidate):
|
[
"\n assert candidate('ABjfK329r0&&*#5t') == 'abjfk329r05t'\n",
"\n assert candidate('jseguwphegoi339yup h') == 'jseguwphegoi339yup h'\n",
"\n assert candidate(' ') == ''\n"
] |
f_30693804
|
lower a string `text` and remove non-alphanumeric characters aside from space
|
[
"re"
] |
|
30,693,804 |
def f_30693804(text):
return
|
re.sub('(?!\\s)[\\W_]', '', text).lower().strip()
|
import re
def check(candidate):
|
[
"\n assert candidate('ABjfK329r0&&*#5t') == 'abjfk329r05t'\n",
"\n assert candidate('jseguwphegoi339yup h') == 'jseguwphegoi339yup h'\n",
"\n assert candidate(' ') == ''\n"
] |
f_30693804
|
remove all non-alphanumeric characters except space from a string `text` and lower it
|
[
"re"
] |
|
17,138,464 |
def f_17138464(x, y):
return
|
plt.plot(x, y, label='H\u2082O')
|
import numpy as np
import matplotlib.pyplot as plt
def check(candidate):
|
[
"\n pic = candidate(np.array([1,2,3]),np.array([4,5,6]))[0]\n assert pic.get_label() == 'H₂O'\n x, y = pic.get_data()\n assert all(x == np.array([1,2,3]))\n assert all(y == np.array([4,5,6]))\n",
"\n pic = candidate(np.array([6, 7, 899]),np.array([0, 1, 245]))[0]\n assert pic.get_label() == 'H₂O'\n x, y = pic.get_data()\n assert all(x == np.array([6, 7, 899]))\n assert all(y == np.array([0, 1, 245]))\n"
] |
f_17138464
|
subscript text 'H20' with '2' as subscripted in matplotlib labels for arrays 'x' and 'y'.
|
[
"matplotlib",
"numpy"
] |
|
17,138,464 |
def f_17138464(x, y):
return
|
plt.plot(x, y, label='$H_2O$')
|
import numpy as np
import matplotlib.pyplot as plt
def check(candidate):
|
[
"\n pic = candidate(np.array([1,2,3]),np.array([4,5,6]))[0]\n assert pic.get_label() == '$H_2O$'\n x, y = pic.get_data()\n assert all(x == np.array([1,2,3]))\n assert all(y == np.array([4,5,6]))\n",
"\n pic = candidate(np.array([6, 7, 899]),np.array([0, 1, 245]))[0]\n assert pic.get_label() == '$H_2O$'\n x, y = pic.get_data()\n assert all(x == np.array([6, 7, 899]))\n assert all(y == np.array([0, 1, 245]))\n"
] |
f_17138464
|
subscript text 'H20' with '2' as subscripted in matplotlib labels for arrays 'x' and 'y'.
|
[
"matplotlib",
"numpy"
] |
|
9,138,112 |
def f_9138112(mylist):
return
|
[x for x in mylist if len(x) == 3]
|
def check(candidate):
|
[
"\n assert candidate([[1,2,3], 'abc', [345,53], 'avsvasf']) == [[1,2,3], 'abc']\n",
"\n assert candidate([[435,654.4,45,2],[34,34,757,65,32423]]) == []\n"
] |
f_9138112
|
loop over a list `mylist` if sublists length equals 3
|
[] |
|
1,807,026 |
def f_1807026():
|
return lst
|
lst = [Object() for _ in range(100)]
|
class Object():
def __init__(self):
self.name = "object"
def check(candidate):
|
[
"\n lst = candidate()\n assert all([x.name == \"object\" for x in lst])\n"
] |
f_1807026
|
initialize a list `lst` of 100 objects Object()
|
[] |
13,793,321 |
def f_13793321(df1, df2):
return
|
df1.merge(df2, on='Date_Time')
|
import pandas as pd
def check(candidate):
|
[
"\n df1 = pd.DataFrame([[1, 2, 3]], columns=[\"Date\", \"Time\", \"Date_Time\"])\n df2 = pd.DataFrame([[1, 3],[4, 9]], columns=[\"Name\", \"Date_Time\"])\n assert candidate(df1, df2).to_dict() == {'Date': {0: 1}, 'Time': {0: 2}, 'Date_Time': {0: 3}, 'Name': {0: 1}}\n"
] |
f_13793321
|
joining data from dataframe `df1` with data from dataframe `df2` based on matching values of column 'Date_Time' in both dataframes
|
[
"pandas"
] |
|
3,367,288 |
def f_3367288(str1):
return
|
'first string is: %s, second one is: %s' % (str1, 'geo.tif')
|
def check(candidate):
|
[
"\n assert candidate(\"s001\") == \"first string is: s001, second one is: geo.tif\"\n",
"\n assert candidate(\"\") == \"first string is: , second one is: geo.tif\"\n",
"\n assert candidate(\" \") == \"first string is: , second one is: geo.tif\"\n"
] |
f_3367288
|
use `%s` operator to print variable values `str1` inside a string
|
[] |
|
3,475,251 |
def f_3475251():
return
|
[x.strip() for x in '2.MATCHES $$TEXT$$ STRING'.split('$$TEXT$$')]
|
def check(candidate):
|
[
"\n assert candidate() == ['2.MATCHES', 'STRING']\n"
] |
f_3475251
|
Split a string '2.MATCHES $$TEXT$$ STRING' by a delimiter '$$TEXT$$'
|
[] |
|
273,192 |
def f_273192(directory):
|
return
|
if (not os.path.exists(directory)):
os.makedirs(directory)
|
import os
def check(candidate):
|
[
"\n candidate(\"hello\")\n assert os.path.exists(\"hello\")\n",
"\n candidate(\"_some_dir\")\n assert os.path.exists(\"_some_dir\")\n"
] |
f_273192
|
check if directory `directory ` exists and create it if necessary
|
[
"os"
] |
273,192 |
def f_273192(path):
|
return
|
try:
os.makedirs(path)
except OSError:
if (not os.path.isdir(path)):
raise
|
import os
def check(candidate):
|
[
"\n candidate(\"hello\")\n assert os.path.exists(\"hello\")\n",
"\n candidate(\"_some_dir\")\n assert os.path.exists(\"_some_dir\")\n"
] |
f_273192
|
check if a directory `path` exists and create it if necessary
|
[
"os"
] |
273,192 |
def f_273192(path):
|
return
|
try:
os.makedirs(path)
except OSError as exception:
if (exception.errno != errno.EEXIST):
raise
|
import os
def check(candidate):
|
[
"\n candidate(\"hello\")\n assert os.path.exists(\"hello\")\n",
"\n candidate(\"_some_dir\")\n assert os.path.exists(\"_some_dir\")\n"
] |
f_273192
|
check if a directory `path` exists and create it if necessary
|
[
"os"
] |
18,785,032 |
def f_18785032(text):
return
|
re.sub('\\bH3\\b', 'H1', text)
|
import re
def check(candidate):
|
[
"\n assert candidate(\"hello world and H3\") == \"hello world and H1\"\n",
"\n assert candidate(\"hello world and H1\") == \"hello world and H1\"\n",
"\n assert candidate(\"hello world!\") == \"hello world!\"\n"
] |
f_18785032
|
Replace a separate word 'H3' by 'H1' in a string 'text'
|
[
"re"
] |
|
1,450,897 |
def f_1450897():
return
|
re.sub('\\D', '', 'aas30dsa20')
|
import re
def check(candidate):
|
[
"\n assert candidate() == \"3020\"\n"
] |
f_1450897
|
substitute ASCII letters in string 'aas30dsa20' with empty string ''
|
[
"re"
] |
|
1,450,897 |
def f_1450897():
return
|
"""""".join([x for x in 'aas30dsa20' if x.isdigit()])
|
def check(candidate):
|
[
"\n assert candidate() == \"3020\"\n"
] |
f_1450897
|
get digits only from a string `aas30dsa20` using lambda function
|
[] |
|
14,435,268 |
def f_14435268(soup):
return
|
soup.find('name').string
|
from bs4 import BeautifulSoup
def check(candidate):
|
[
"\n content = \"<contact><name>LastName</name><lastName>FirstName</lastName><phone>+90 333 12345</phone></contact>\"\n soup = BeautifulSoup(content)\n assert candidate(soup) == \"LastName\"\n",
"\n content = \"<name>hello world!</name>\"\n soup = BeautifulSoup(content)\n assert candidate(soup) == \"hello world!\"\n"
] |
f_14435268
|
access a tag called "name" in beautifulsoup `soup`
|
[
"bs4"
] |
|
20,180,210 |
def f_20180210(A, B):
return
|
np.concatenate((A, B))
|
import numpy as np
def check(candidate):
|
[
"\n A = np.array([1,2])\n B = np.array([3,4])\n assert np.allclose(candidate(A, B), np.array([1,2,3,4]))\n",
"\n A = np.array([[1,2]])\n B = np.array([[3,4]])\n assert np.allclose(candidate(A, B), np.array([[1,2],[3,4]]))\n",
"\n A = np.array([[1],[2]])\n B = np.array([[3],[4]])\n assert np.allclose(candidate(A, B), np.array([[1],[2],[3],[4]]))\n",
"\n a = np.array([[1, 3, 4], [4, 5, 6], [6, 0, -1]])\n b = np.array([[5, 6, 1], [0, 2, -1], [9, 4, 1]])\n expected = np.array([[ 1, 3, 4], [ 4, 5, 6],\n [ 6, 0, -1], [ 5, 6, 1], [ 0, 2, -1], [ 9, 4, 1]])\n assert np.array_equal(candidate(a, b), expected)\n"
] |
f_20180210
|
Create new matrix object by concatenating data from matrix A and matrix B
|
[
"numpy"
] |
|
20,180,210 |
def f_20180210(A, B):
return
|
np.vstack((A, B))
|
import numpy as np
def check(candidate):
|
[
"\n A = np.array([1,2])\n B = np.array([3,4])\n assert np.allclose(candidate(A, B), np.array([[1,2],[3,4]]))\n",
"\n A = np.array([[1,2]])\n B = np.array([[3,4]])\n assert np.allclose(candidate(A, B), np.array([[1,2],[3,4]]))\n",
"\n A = np.array([[1],[2]])\n B = np.array([[3],[4]])\n assert np.allclose(candidate(A, B), np.array([[1],[2],[3],[4]]))\n",
"\n a = np.array([[1, 3, 4], [4, 5, 6], [6, 0, -1]])\n b = np.array([[5, 6, 1], [0, 2, -1], [9, 4, 1]])\n expected = np.array([[ 1, 3, 4], [ 4, 5, 6],\n [ 6, 0, -1], [ 5, 6, 1], [ 0, 2, -1], [ 9, 4, 1]])\n assert np.array_equal(candidate(a, b), expected)\n"
] |
f_20180210
|
concat two matrices `A` and `B` in numpy
|
[
"numpy"
] |
End of preview. Expand
in Data Studio
ODEX is an Open-Domain EXecution-based NL-to-Code generation data benchmark. It contains 945 samples with a total of 1,707 human-written test cases, covering intents in four different natural languages -- 439 in English, 90 in Spanish, 164 in Japanese, and 252 in Russian.
You can load the dataset by specifying a subset from en, es, ja, ru (by default the english subset en is loaded):
from datasets import load_dataset
ds = load_dataset("neulab/odex", "ja", split="test")
If you find our dataset useful, please cite the paper
@article{wang2022execution,
title={Execution-Based Evaluation for Open-Domain Code Generation},
author={Zhiruo Wang, Shuyan Zhou, Daniel Fried, Graham Neubig},
journal={arXiv preprint arXiv:2212.10481},
year={2022}
}
- Downloads last month
- 108