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 Dataset Viewer.
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
- 2,201