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 |
|---|---|---|---|---|---|---|---|---|
638,048 | def f_638048(list_of_pairs):
return | sum([pair[0] for pair in list_of_pairs]) |
def check(candidate): | [
"\n assert candidate([(5, 9), (-1, -2), (4, 2)]) == 8\n"
] | f_638048 | sum the first value in each tuple in a list of tuples `list_of_pairs` in python | [] |
|
14,950,260 | def f_14950260():
return | ast.literal_eval("{'code1':1,'code2':1}") |
import ast
def check(candidate): | [
"\n d = candidate()\n exp_result = {'code1' : 1, 'code2': 1}\n for key in d:\n if key not in exp_result:\n assert False\n else:\n assert d[key] == exp_result[key]\n"
] | f_14950260 | convert unicode string u"{'code1':1,'code2':1}" into dictionary | [
"ast"
] |
|
11,416,772 | def f_11416772(mystring):
return | [word for word in mystring.split() if word.startswith('$')] |
def check(candidate): | [
"\n str = \"$abc def $efg $hij klm $\"\n exp_result = ['$abc', '$efg', '$hij', '$']\n assert sorted(candidate(str)) == sorted(exp_result)\n"
] | f_11416772 | find all words in a string `mystring` that start with the `$` sign | [] |
|
11,331,982 | def f_11331982(text):
|
return text | text = re.sub('^https?:\\/\\/.*[\\r\\n]*', '', text, flags=re.MULTILINE) |
import re
def check(candidate): | [
"\n assert candidate(\"https://www.wikipedia.org/ click at\") == \"\"\n"
] | f_11331982 | remove any url within string `text` | [
"re"
] |
34,945,274 | def f_34945274(A):
return | np.where(np.in1d(A, [1, 3, 4]).reshape(A.shape), A, 0) |
import numpy as np
def check(candidate): | [
"\n A = np.array([[6, 8, 1, 3, 4], [-1, 0, 3, 5, 1]])\n B = np.array([[0, 0, 1, 3, 4], [0, 0, 3, 0, 1]])\n assert np.array_equal(candidate(A), B)\n"
] | f_34945274 | replace all elements in array `A` that are not present in array `[1, 3, 4]` with zeros | [
"numpy"
] |
|
15,819,980 | def f_15819980(a):
return | np.mean(a, axis=1) |
import numpy as np
def check(candidate): | [
"\n A = np.array([[6, 8, 1, 3, 4], [-1, 0, 3, 5, 1]])\n B = np.array([4.4, 1.6])\n assert np.array_equal(candidate(A), B)\n"
] | f_15819980 | calculate mean across dimension in a 2d array `a` | [
"numpy"
] |
|
19,894,365 | def f_19894365():
return | subprocess.call(['/usr/bin/Rscript', '--vanilla', '/pathto/MyrScript.r']) |
from unittest.mock import Mock
import subprocess
def check(candidate): | [
"\n subprocess.call = Mock(return_value = 0)\n assert candidate() == 0\n"
] | f_19894365 | running r script '/pathto/MyrScript.r' from python | [
"subprocess"
] |
|
19,894,365 | def f_19894365():
return | subprocess.call('/usr/bin/Rscript --vanilla /pathto/MyrScript.r', shell=True) |
from unittest.mock import Mock
import subprocess
def check(candidate): | [
"\n subprocess.call = Mock(return_value = 0)\n assert candidate() == 0\n"
] | f_19894365 | run r script '/usr/bin/Rscript --vanilla /pathto/MyrScript.r' | [
"subprocess"
] |
|
33,058,590 | def f_33058590(df):
return | df.fillna(df.mean(axis=0)) |
import pandas as pd
import numpy as np
def check(candidate): | [
"\n df = pd.DataFrame([[1,2,3],[4,5,6],[7.0,np.nan,9.0]], columns=[\"c1\",\"c2\",\"c3\"]) \n res = pd.DataFrame([[1,2,3],[4,5,6],[7.0,3.5,9.0]], columns=[\"c1\",\"c2\",\"c3\"])\n assert candidate(df).equals(res)\n"
] | f_33058590 | replacing nan in the dataframe `df` with row average | [
"numpy",
"pandas"
] |
|
12,400,256 | def f_12400256():
return | time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1347517370)) |
import time
def check(candidate): | [
"\n assert candidate() == \"2012-09-13 06:22:50\"\n"
] | f_12400256 | Convert unix timestamp '1347517370' to formatted string '%Y-%m-%d %H:%M:%S' | [
"time"
] |
|
23,359,886 | def f_23359886(a):
return | a[np.where((a[:, (0)] == 0) * (a[:, (1)] == 1))] |
import numpy as np
def check(candidate): | [
"\n a = np.array([[ 0, 1, 2], [ 3, 4, 5], [ 6, 7, 8], [ 9, 10, 11], [12, 13, 14]])\n res = np.array([[0, 1, 2]])\n assert np.array_equal(candidate(a), res)\n"
] | f_23359886 | selecting rows in Numpy ndarray 'a', where the value in the first column is 0 and value in the second column is 1 | [
"numpy"
] |
|
4,383,082 | def f_4383082(words):
return | re.split(' +', words) |
import regex as re
def check(candidate): | [
"\n s = \"hello world sample text\"\n res = [\"hello\", \"world\", \"sample\", \"text\"]\n assert candidate(s) == res\n"
] | f_4383082 | separate words delimited by one or more spaces into a list | [
"regex"
] |
|
14,637,696 | def f_14637696(words):
return | len(max(words, key=len)) |
def check(candidate): | [
"\n assert candidate([\"hello\", \"world\", \"sample\", \"text\", \"superballer\"]) == 11\n"
] | f_14637696 | length of longest element in list `words` | [] |
|
3,933,478 | def f_3933478(result):
return | result[0]['from_user'] |
def check(candidate): | [
"\n Contents = [{\"hi\": 7, \"bye\": 4, \"from_user\": 0}, {1: 2, 3: 4, 5: 6}]\n assert candidate(Contents) == 0\n"
] | f_3933478 | get the value associated with unicode key 'from_user' of first dictionary in list `result` | [] |
|
39,112,645 | def f_39112645():
return | [line.split() for line in open('File.txt')] |
def check(candidate): | [
"\n with open('File.txt','w') as fw:\n fw.write(\"hi hello cat dog\")\n assert candidate() == [['hi', 'hello', 'cat', 'dog']]\n"
] | f_39112645 | Retrieve each line from a file 'File.txt' as a list | [] |
|
1,031,851 | def f_1031851(a):
return | dict((v, k) for k, v in a.items()) |
def check(candidate): | [
"\n a = {\"one\": 1, \"two\": 2}\n assert candidate(a) == {1: \"one\", 2: \"two\"}\n"
] | f_1031851 | swap keys with values in a dictionary `a` | [] |
|
8,577,137 | def f_8577137():
return | open('path/to/FILE_NAME.ext', 'w') |
import os
def check(candidate): | [
"\n path1 = os.path.join(\"\", \"path\")\n os.mkdir(path1)\n path2 = os.path.join(\"path\", \"to\")\n os.mkdir(path2)\n candidate()\n assert os.path.exists('path/to/FILE_NAME.ext')\n"
] | f_8577137 | Open a file `path/to/FILE_NAME.ext` in write mode | [
"os"
] |
|
17,926,273 | def f_17926273(df):
return | df.groupby(['col1', 'col2'])['col3'].nunique().reset_index() |
import pandas as pd
def check(candidate): | [
"\n data = [[1, 1, 1], [1, 1, 1], [1, 1, 2], [1, 2, 3], [1, 2, 3], [1, 2, 3], \n [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 3], [2, 2, 3], [2, 2, 3]]\n expected = [[1, 1, 2], [1, 2, 1], [2, 1, 3], [2, 2, 1]]\n df = pd.DataFrame(data, columns = ['col1', 'col2', 'col3'])\n expected_df = pd.DataFrame(expected, columns = ['col1', 'col2', 'col3'])\n df1 = candidate(df)\n assert pd.DataFrame.equals(expected_df, df1)\n"
] | f_17926273 | count distinct values in a column 'col3' of a pandas dataframe `df` group by objects in 'col1' and 'col2' | [
"pandas"
] |
|
3,735,814 | def f_3735814(dict1):
return | any(key.startswith('EMP$$') for key in dict1) |
def check(candidate): | [
"\n assert candidate({'EMP$$': 1, 'EMP$$112': 4}) == True\n",
"\n assert candidate({'EMP$$': 1, 'EM$$112': 4}) == True\n",
"\n assert candidate({'EMP$33': 0}) == False\n"
] | f_3735814 | Check if any key in the dictionary `dict1` starts with the string `EMP$$` | [] |
|
3,735,814 | def f_3735814(dict1):
return | [value for key, value in list(dict1.items()) if key.startswith('EMP$$')] |
def check(candidate): | [
"\n assert sorted(candidate({'EMP$$': 1, 'EMP$$112': 4})) == [1, 4]\n",
"\n assert sorted(candidate({'EMP$$': 1, 'EM$$112': 4})) == [1]\n",
"\n assert sorted(candidate({'EMP$33': 0})) == []\n"
] | f_3735814 | create list of values from dictionary `dict1` that have a key that starts with 'EMP$$' | [] |
|
26,097,916 | def f_26097916(sf):
|
return df | df = pd.DataFrame({'email': sf.index, 'list': sf.values}) |
import pandas as pd
def check(candidate): | [
"\n dict = {'email1': [1.0, 5.0, 7.0], 'email2': [4.2, 3.6, -0.9]}\n sf = pd.Series(dict)\n k = [['email1', [1.0, 5.0, 7.0]], ['email2', [4.2, 3.6, -0.9]]]\n df1 = pd.DataFrame(k, columns=['email', 'list'])\n df2 = candidate(sf)\n assert pd.DataFrame.equals(df1, df2)\n"
] | f_26097916 | convert a pandas series `sf` into a pandas dataframe `df` with columns `email` and `list` | [
"pandas"
] |
4,048,964 | def f_4048964(list):
return | '\t'.join(map(str, list)) |
def check(candidate): | [
"\n assert candidate(['hello', 'world', '!']) == 'hello\\tworld\\t!'\n",
"\n assert candidate([]) == \"\"\n",
"\n assert candidate([\"mconala\"]) == \"mconala\"\n",
"\n assert candidate([\"MCoNaLa\"]) == \"MCoNaLa\"\n"
] | f_4048964 | concatenate elements of list `list` by tabs ` ` | [] |
|
3,182,716 | def f_3182716():
return | '\xd0\xbf\xd1\x80\xd0\xb8'.encode('raw_unicode_escape') |
def check(candidate): | [
"\n assert candidate() == b'\\xd0\\xbf\\xd1\\x80\\xd0\\xb8'\n"
] | f_3182716 | print unicode string '\xd0\xbf\xd1\x80\xd0\xb8' with utf-8 | [] |
|
3,182,716 | def f_3182716():
return | 'Sopet\xc3\xb3n'.encode('latin-1').decode('utf-8') |
def check(candidate): | [
"\n assert candidate() == \"Sopetón\"\n"
] | f_3182716 | Encode a latin character in string `Sopet\xc3\xb3n` properly | [] |
|
35,622,945 | def f_35622945(s):
return | re.findall('n(?<=[^n]n)n+(?=[^n])(?i)', s) |
import re
def check(candidate): | [
"\n assert candidate(\"ncnnnne\") == ['nnnn']\n",
"\n assert candidate(\"nn\") == []\n",
"\n assert candidate(\"ask\") == []\n"
] | f_35622945 | regex, find "n"s only in the middle of string `s` | [
"re"
] |
|
5,306,756 | def f_5306756():
return | '{0:.0f}%'.format(1.0 / 3 * 100) |
def check(candidate): | [
"\n assert(candidate() == \"33%\")\n"
] | f_5306756 | display the float `1/3*100` as a percentage | [] |
|
2,878,084 | def f_2878084(mylist):
|
return mylist | mylist.sort(key=lambda x: x['title']) |
def check(candidate): | [
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] | f_2878084 | sort a list of dictionary `mylist` by the key `title` | [] |
2,878,084 | def f_2878084(l):
|
return l | l.sort(key=lambda x: x['title']) |
def check(candidate): | [
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] | f_2878084 | sort a list `l` of dicts by dict value 'title' | [] |
2,878,084 | def f_2878084(l):
|
return l | l.sort(key=lambda x: (x['title'], x['title_url'], x['id'])) |
def check(candidate): | [
"\n input = [\n {'title':'New York Times', 'title_url':'New_York_Times','id':4}, \n {'title':'USA Today','title_url':'USA_Today','id':6}, \n {'title':'Apple News','title_url':'Apple_News','id':2}\n ]\n res = [\n {'title': 'Apple News', 'title_url': 'Apple_News', 'id': 2}, \n {'title': 'New York Times', 'title_url': 'New_York_Times', 'id': 4},\n {'title': 'USA Today', 'title_url': 'USA_Today', 'id': 6}\n ]\n assert candidate(input) == res\n"
] | f_2878084 | sort a list of dictionaries by the value of keys 'title', 'title_url', 'id' in ascending order. | [] |
9,323,159 | def f_9323159(l1, l2):
return | heapq.nlargest(10, range(len(l1)), key=lambda i: abs(l1[i] - l2[i])) |
import heapq
def check(candidate): | [
"\n l1 = [99, 86, 90, 70, 86, 95, 56, 98, 80, 81]\n l2 = [21, 11, 21, 1, 26, 40, 4, 50, 34, 37]\n res = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n assert candidate(l1, l2) == res\n"
] | f_9323159 | find 10 largest differences between each respective elements of list `l1` and list `l2` | [
"heapq"
] |
|
29,877,663 | def f_29877663(soup):
return | soup.find_all('span', {'class': 'starGryB sp'}) |
import bs4
def check(candidate): | [
"\n html = '''<span class=\"starBig sp\">4.1</span>\n <span class=\"starGryB sp\">2.9</span>\n <span class=\"sp starGryB\">2.9</span>\n <span class=\"sp starBig\">22</span>'''\n soup = bs4.BeautifulSoup(html, features=\"html5lib\")\n res = '''[<span class=\"starGryB sp\">2.9</span>]'''\n assert(str(candidate(soup)) == res)\n"
] | f_29877663 | BeautifulSoup find all 'span' elements in HTML string `soup` with class of 'starGryB sp' | [
"bs4"
] |
|
24,189,150 | def f_24189150(df, engine):
|
return | df.to_sql('test', engine) |
import pandas as pd
from sqlalchemy import create_engine
def check(candidate): | [
"\n engine = create_engine('sqlite://', echo=False)\n df = pd.DataFrame({'name' : ['User 1', 'User 2', 'User 3']})\n candidate(df, engine)\n result = pd.read_sql('SELECT name FROM test', engine)\n assert result.equals(df)\n"
] | f_24189150 | write records in dataframe `df` to table 'test' in schema 'a_schema' with `engine` | [
"pandas",
"sqlalchemy"
] |
30,766,151 | def f_30766151(s):
return | re.sub('[^(){}[\]]', '', s) |
import re
def check(candidate): | [
"\n assert candidate(\"(a(vdwvndw){}]\") == \"((){}]\"\n",
"\n assert candidate(\"12345\") == \"\"\n"
] | f_30766151 | Extract brackets from string `s` | [
"re"
] |
|
1,143,379 | def f_1143379(L):
return | list(dict((x[0], x) for x in L).values()) |
def check(candidate): | [
"\n L = [['14', '65', 76], ['2', '5', 6], ['7', '12', 33], ['14', '22', 46]]\n res = [['14', '22', 46], ['2', '5', 6], ['7', '12', 33]]\n assert(candidate(L) == res)\n",
"\n assert candidate([\"a\", \"aa\", \"abc\", \"bac\"]) == [\"abc\", \"bac\"]\n"
] | f_1143379 | remove duplicate elements from list 'L' | [] |
|
12,330,522 | def f_12330522(file):
return | [line.rstrip('\n') for line in file] |
def check(candidate): | [
"\n res = ['1', '2', '3']\n f = open(\"myfile.txt\", \"a\")\n f.write(\"1\\n2\\n3\")\n f.close()\n f = open(\"myfile.txt\", \"r\")\n assert candidate(f) == res\n"
] | f_12330522 | read a file `file` without newlines | [] |
|
364,621 | def f_364621(testlist):
return | [i for (i, x) in enumerate(testlist) if (x == 1)] |
def check(candidate): | [
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist) == [0, 5, 7]\n",
"\n testlist = [0, -1]\n assert candidate(testlist) == []\n"
] | f_364621 | get the position of item 1 in `testlist` | [] |
|
364,621 | def f_364621(testlist):
return | [i for (i, x) in enumerate(testlist) if (x == 1)] |
def check(candidate): | [
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist) == [0, 5, 7]\n",
"\n testlist = [0, -1]\n assert candidate(testlist) == []\n"
] | f_364621 | get the position of item 1 in `testlist` | [] |
|
364,621 | def f_364621(testlist, element):
return | testlist.index(element) |
def check(candidate): | [
"\n testlist = [1,2,3,5,3,1,2,1,6]\n assert candidate(testlist, 1) == 0\n",
"\n testlist = [1,2,3,5,3,1,2,1,6]\n try:\n candidate(testlist, 14)\n except:\n assert True\n"
] | f_364621 | get the position of item `element` in list `testlist` | [] |
|
13,145,368 | def f_13145368(lis):
return | max(lis, key=lambda item: item[1])[0] |
def check(candidate): | [
"\n lis = [(101, 153), (255, 827), (361, 961)]\n assert candidate(lis) == 361\n"
] | f_13145368 | find the first element of the tuple with the maximum second element in a list of tuples `lis` | [] |
|
13,145,368 | def f_13145368(lis):
return | max(lis, key=itemgetter(1))[0] |
from operator import itemgetter
def check(candidate): | [
"\n lis = [(101, 153), (255, 827), (361, 961)]\n assert candidate(lis) == 361\n"
] | f_13145368 | get the item at index 0 from the tuple that has maximum value at index 1 in list `lis` | [
"operator"
] |
|
2,689,189 | def f_2689189():
|
return | time.sleep(1) |
import time
def check(candidate): | [
"\n t1 = time.time()\n candidate()\n t2 = time.time()\n assert t2 - t1 > 1\n"
] | f_2689189 | Make a delay of 1 second | [
"time"
] |
12,485,244 | def f_12485244(L):
return | """, """.join('(' + ', '.join(i) + ')' for i in L) |
def check(candidate): | [
"\n L = [(\"abc\", \"def\"), (\"hij\", \"klm\")]\n assert candidate(L) == '(abc, def), (hij, klm)'\n"
] | f_12485244 | convert list of tuples `L` to a string | [] |
|
755,857 | def f_755857():
|
return b | b = models.CharField(max_length=7, default='0000000', editable=False) |
from django.db import models
def check(candidate): | [
"\n assert candidate().get_default() == '0000000'\n"
] | f_755857 | Django set default value of field `b` equal to '0000000' | [
"django"
] |
16,193,578 | def f_16193578(list5):
return | sorted(list5, key = lambda x: (degrees(x), x)) |
from math import degrees
def check(candidate): | [
"\n list5 = [4, 1, 2, 3, 9, 5]\n assert candidate(list5) == [1, 2, 3, 4, 5, 9]\n"
] | f_16193578 | Sort lis `list5` in ascending order based on the degrees value of its elements | [
"math"
] |
|
16,041,405 | def f_16041405(l):
return | (n for n in l) |
def check(candidate): | [
"\n generator = candidate([1,2,3,5])\n assert str(type(generator)) == \"<class 'generator'>\"\n assert [x for x in generator] == [1, 2, 3, 5]\n"
] | f_16041405 | convert a list `l` into a generator object | [] |
|
18,837,607 | def f_18837607(oldlist, removelist):
return | [v for i, v in enumerate(oldlist) if i not in removelist] |
def check(candidate): | [
"\n assert candidate([\"asdf\",\"ghjk\",\"qwer\",\"tyui\"], [1,3]) == ['asdf', 'qwer']\n",
"\n assert candidate([1,2,3,4,5], [0,4]) == [2,3,4]\n"
] | f_18837607 | remove elements from list `oldlist` that have an index number mentioned in list `removelist` | [] |
|
4,710,067 | def f_4710067():
return | open('yourfile.txt', 'w') |
def check(candidate): | [
"\n fw = candidate()\n assert fw.name == \"yourfile.txt\"\n assert fw.mode == 'w'\n"
] | f_4710067 | Open a file `yourfile.txt` in write mode | [] |
|
7,373,219 | def f_7373219(obj, attr):
return | getattr(obj, attr) |
def check(candidate): | [
"\n class Student:\n student_id = \"\"\n student_name = \"\"\n\n def __init__(self, student_id=101, student_name=\"Adam\"):\n self.student_id = student_id\n self.student_name = student_name\n\n student = Student()\n\n assert(candidate(student, 'student_name') == \"Adam\")\n assert(candidate(student, 'student_id') == 101)\n",
"\n class Student:\n student_id = \"\"\n student_name = \"\"\n\n def __init__(self, student_id=101, student_name=\"Adam\"):\n self.student_id = student_id\n self.student_name = student_name\n\n student = Student()\n\n try:\n value = candidate(student, 'student_none')\n except: \n assert True\n"
] | f_7373219 | get attribute 'attr' from object `obj` | [] |
|
8,171,751 | def f_8171751():
return | reduce(lambda a, b: a + b, (('aa',), ('bb',), ('cc',))) |
from functools import reduce
def check(candidate): | [
"\n assert candidate() == ('aa', 'bb', 'cc')\n"
] | f_8171751 | convert tuple of tuples `(('aa',), ('bb',), ('cc',))` to tuple | [
"functools"
] |
|
8,171,751 | def f_8171751():
return | list(map(lambda a: a[0], (('aa',), ('bb',), ('cc',)))) |
def check(candidate): | [
"\n assert candidate() == ['aa', 'bb', 'cc']\n"
] | f_8171751 | convert tuple of tuples `(('aa',), ('bb',), ('cc',))` to list in one line | [] |
|
28,986,489 | def f_28986489(df):
|
return df | df['range'].replace(',', '-', inplace=True) |
import pandas as pd
def check(candidate): | [
"\n df = pd.DataFrame({'range' : [\",\", \"(50,290)\", \",,,\"]})\n res = pd.DataFrame({'range' : [\"-\", \"(50,290)\", \",,,\"]})\n assert candidate(df).equals(res)\n"
] | f_28986489 | replace a characters in a column of a dataframe `df` | [
"pandas"
] |
19,339 | def f_19339():
return | zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)]) |
def check(candidate): | [
"\n assert [a for a in candidate()] == [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]\n"
] | f_19339 | unzip the list `[('a', 1), ('b', 2), ('c', 3), ('d', 4)]` | [] |
|
19,339 | def f_19339(original):
return | ([a for (a, b) in original], [b for (a, b) in original]) |
def check(candidate): | [
"\n original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]\n assert candidate(original) == (['a', 'b', 'c', 'd'], [1, 2, 3, 4])\n",
"\n original2 = [([], 1), ([], 2), (5, 3), (6, 4)]\n assert candidate(original2) == ([[], [], 5, 6], [1, 2, 3, 4])\n"
] | f_19339 | unzip list `original` | [] |
|
19,339 | def f_19339(original):
return | ((a for (a, b) in original), (b for (a, b) in original)) |
def check(candidate): | [
"\n original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]\n result = candidate(original)\n assert [a for gen in result for a in gen] == ['a','b','c','d',1,2,3,4]\n",
"\n original2 = [([], 1), ([], 2), (5, 3), (6, 4)]\n result2 = candidate(original2)\n assert [a for gen in result2 for a in gen] == [[], [], 5, 6, 1, 2, 3, 4]\n"
] | f_19339 | unzip list `original` and return a generator | [] |
|
19,339 | def f_19339():
return | zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e',)]) |
def check(candidate): | [
"\n assert list(candidate()) == [('a', 'b', 'c', 'd', 'e')]\n"
] | f_19339 | unzip list `[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )]` | [] |
|
19,339 | def f_19339():
return | list(zip_longest(('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e',))) |
from itertools import zip_longest
def check(candidate): | [
"\n assert(candidate() == [('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)])\n"
] | f_19339 | unzip list `[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )]` and fill empty results with None | [
"itertools"
] |
|
1,960,516 | def f_1960516():
return | json.dumps('3.9') |
import json
def check(candidate): | [
"\n data = candidate()\n assert json.loads(data) == '3.9'\n"
] | f_1960516 | encode `Decimal('3.9')` to a JSON string | [
"json"
] |
|
1,024,847 | def f_1024847(d):
|
return d | d['mynewkey'] = 'mynewvalue' |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'mynewkey': 'mynewvalue'}\n"
] | f_1024847 | Add key "mynewkey" to dictionary `d` with value "mynewvalue" | [] |
1,024,847 | def f_1024847(data):
|
return data | data.update({'a': 1, }) |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] | f_1024847 | Add key 'a' to dictionary `data` with value 1 | [] |
1,024,847 | def f_1024847(data):
|
return data | data.update(dict(a=1)) |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] | f_1024847 | Add key 'a' to dictionary `data` with value 1 | [] |
1,024,847 | def f_1024847(data):
|
return data | data.update(a=1) |
def check(candidate): | [
"\n assert candidate({'key': 'value'}) == {'key': 'value', 'a': 1}\n",
"\n assert candidate({'key': 'value', 'a' : 2}) == {'key': 'value', 'a': 1}\n"
] | f_1024847 | Add key 'a' to dictionary `data` with value 1 | [] |
35,837,346 | def f_35837346(matrix):
return | max([max(i) for i in matrix]) |
def check(candidate): | [
"\n assert candidate([[1,2,3],[4,5,6],[7,8,9]]) == 9\n",
"\n assert candidate([[1.3,2.8],[4.2,10],[7.9,8.1,5]]) == 10\n"
] | f_35837346 | find maximal value in matrix `matrix` | [] |
|
20,457,038 | def f_20457038(answer):
|
return answer | answer = str(round(answer, 2)) |
def check(candidate): | [
"\n assert candidate(2.34351) == \"2.34\"\n",
"\n assert candidate(99.375) == \"99.38\"\n",
"\n assert candidate(4.1) == \"4.1\"\n",
"\n assert candidate(3) == \"3\"\n"
] | f_20457038 | Round number `answer` to 2 precision after the decimal point | [] |
2,890,896 | def f_2890896(s):
|
return ip | ip = re.findall('[0-9]+(?:\\.[0-9]+){3}', s) |
import re
def check(candidate): | [
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 165.91.15.131</body></html>\") == [\"165.91.15.131\"]\n",
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 165.91.15.131 and this is not a IP Address: 165.91.15</body></html>\") == [\"165.91.15.131\"]\n",
"\n assert candidate(\"<html><head><title>Current IP Check</title></head><body>Current IP Address: 192.168.1.1 & this is another IP address: 192.168.1.2</body></html>\") == [\"192.168.1.1\", \"192.168.1.2\"]\n"
] | f_2890896 | extract ip address `ip` from an html string `s` | [
"re"
] |
29,836,836 | def f_29836836(df):
return | df.groupby('A').filter(lambda x: len(x) > 1) |
import pandas as pd
def check(candidate): | [
"\n assert candidate(pd.DataFrame([[1, 2], [1, 4], [5, 6]], columns=['A', 'B'])).equals(pd.DataFrame([[1, 2], [1, 4]], columns=['A', 'B'])) is True\n",
"\n assert candidate(pd.DataFrame([[1, 2], [1, 4], [1, 6]], columns=['A', 'B'])).equals(pd.DataFrame([[1, 2], [1, 4], [1, 6]], columns=['A', 'B'])) is True\n"
] | f_29836836 | filter dataframe `df` by values in column `A` that appear more than once | [
"pandas"
] |
|
2,545,397 | def f_2545397(myfile):
return | [x for x in myfile if x != ''] |
def check(candidate): | [
"\n with open('./tmp.txt', 'w') as fw: \n for s in [\"hello\", \"world\", \"!!!\"]:\n fw.write(f\"{s}\\n\")\n\n with open('./tmp.txt', 'r') as myfile:\n lines = candidate(myfile)\n assert isinstance(lines, list)\n assert len(lines) == 3\n assert lines[0].strip() == \"hello\"\n"
] | f_2545397 | append each line in file `myfile` into a list | [] |
|
2,545,397 | def f_2545397():
|
return lst | lst = list(map(int, open('filename.txt').readlines())) |
import pandas as pd
def check(candidate): | [
"\n with open('./filename.txt', 'w') as fw: \n for s in [\"1\", \"2\", \"100\"]:\n fw.write(f\"{s}\\n\")\n\n assert candidate() == [1, 2, 100]\n"
] | f_2545397 | Get a list of integers `lst` from a file `filename.txt` | [
"pandas"
] |
35,420,052 | def f_35420052(plt, mappable, ax3):
|
return plt | plt.colorbar(mappable=mappable, cax=ax3) |
import numpy as np
import matplotlib.pyplot as plt
from obspy.core.trace import Trace
from obspy.imaging.spectrogram import spectrogram
def check(candidate): | [
"\n spl1 = Trace(data=np.arange(0, 10))\n fig = plt.figure()\n ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2]) #[left bottom width height]\n ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)\n ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])\n\n #make time vector\n t = np.arange(spl1.stats.npts) / spl1.stats.sampling_rate\n\n #plot waveform (top subfigure) \n ax1.plot(t, spl1.data, 'k')\n\n #plot spectrogram (bottom subfigure)\n spl2 = spl1\n fig = spl2.spectrogram(show=False, axes=ax2, wlen=10)\n mappable = ax2.images[0]\n candidate(plt, mappable, ax3)\n \n im=ax2.images\n assert im[-1].colorbar is not None\n"
] | f_35420052 | add color bar with image `mappable` to plot `plt` | [
"matplotlib",
"numpy",
"obspy"
] |
29,903,025 | def f_29903025(df):
return | Counter(' '.join(df['text']).split()).most_common(100) |
import pandas as pd
from collections import Counter
def check(candidate): | [
"\n df = pd.DataFrame({\"text\": [\n 'Python is a high-level, general-purpose programming language.', \n 'Its design philosophy emphasizes code readability with the use of significant indentation. Python is dynamically-typed and garbage-collected.'\n ]})\n assert candidate(df) == [('Python', 2),('is', 2),('a', 1),('high-level,', 1),('general-purpose', 1),\n ('programming', 1),('language.', 1),('Its', 1),('design', 1),('philosophy', 1),('emphasizes', 1),\n ('code', 1),('readability', 1),('with', 1), ('the', 1),('use', 1),('of', 1),('significant', 1),\n ('indentation.', 1),('dynamically-typed', 1),('and', 1),('garbage-collected.', 1)]\n"
] | f_29903025 | count most frequent 100 words in column 'text' of dataframe `df` | [
"collections",
"pandas"
] |
|
7,378,180 | def f_7378180():
return | list(itertools.combinations((1, 2, 3), 2)) |
import itertools
def check(candidate): | [
"\n assert candidate() == [(1, 2), (1, 3), (2, 3)]\n"
] | f_7378180 | generate all 2-element subsets of tuple `(1, 2, 3)` | [
"itertools"
] |
|
4,530,069 | def f_4530069():
return | datetime.now(pytz.utc) |
import pytz
import time
from datetime import datetime, timezone
def check(candidate): | [
"\n assert (candidate() - datetime(1970, 1, 1).replace(tzinfo=timezone.utc)).total_seconds() - time.time() <= 1\n"
] | f_4530069 | get a value of datetime.today() in the UTC time zone | [
"datetime",
"pytz",
"time"
] |
|
4,842,956 | def f_4842956(list1):
|
return list2 | list2 = [x for x in list1 if x != []] |
def check(candidate): | [
"\n assert candidate([[\"a\"], [], [\"b\"]]) == [[\"a\"], [\"b\"]]\n",
"\n assert candidate([[], [1,2,3], [], [\"b\"]]) == [[1,2,3], [\"b\"]]\n"
] | f_4842956 | Get a new list `list2`by removing empty list from a list of lists `list1` | [] |
4,842,956 | def f_4842956(list1):
|
return list2 | list2 = [x for x in list1 if x] |
def check(candidate): | [
"\n assert candidate([[\"a\"], [], [\"b\"]]) == [[\"a\"], [\"b\"]]\n",
"\n assert candidate([[], [1,2,3], [], [\"b\"]]) == [[1,2,3], [\"b\"]]\n"
] | f_4842956 | Create `list2` to contain the lists from list `list1` excluding the empty lists from `list1` | [] |
9,262,278 | def f_9262278(data):
return | HttpResponse(data, content_type='application/json') |
import os
import json
from django.http import HttpResponse
from django.conf import settings
if not settings.configured:
settings.configure(DEBUG=True)
def check(candidate): | [
"\n if settings.DEBUG:\n assert candidate(json.dumps({\"Sample-Key\": \"Sample-Value\"})).content == b'{\"Sample-Key\": \"Sample-Value\"}'\n",
"\n if settings.DEBUG:\n assert candidate(json.dumps({\"Sample-Key\": \"Sample-Value\"}))['content-type'] == 'application/json'\n"
] | f_9262278 | Django response with JSON `data` | [
"django",
"json",
"os"
] |
|
17,284,947 | def f_17284947(example_str):
return | re.findall('(.*?)\\[.*?\\]', example_str) |
import re
def check(candidate): | [
"\n list_elems = candidate(\"Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]\")\n assert \"\".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'\n"
] | f_17284947 | get all text that is not enclosed within square brackets in string `example_str` | [
"re"
] |
|
17,284,947 | def f_17284947(example_str):
return | re.findall('(.*?)(?:\\[.*?\\]|$)', example_str) |
import re
def check(candidate): | [
"\n list_elems = candidate(\"Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]\")\n assert \"\".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'\n"
] | f_17284947 | Use a regex to get all text in a string `example_str` that is not surrounded by square brackets | [
"re"
] |
|
14,182,339 | def f_14182339():
return | re.findall('\\(.+?\\)|\\w', '(zyx)bc') |
import re
def check(candidate): | [
"\n assert candidate() == ['(zyx)', 'b', 'c']\n"
] | f_14182339 | get whatever is between parentheses as a single match, and any char outside as an individual match in string '(zyx)bc' | [
"re"
] |
|
14,182,339 | def f_14182339():
return | re.findall('\\((.*?)\\)|(\\w)', '(zyx)bc') |
import re
def check(candidate): | [
"\n assert candidate() == [('zyx', ''), ('', 'b'), ('', 'c')]\n"
] | f_14182339 | match regex '\\((.*?)\\)|(\\w)' with string '(zyx)bc' | [
"re"
] |
|
14,182,339 | def f_14182339():
return | re.findall('\\(.*?\\)|\\w', '(zyx)bc') |
import re
def check(candidate): | [
"\n assert candidate() == ['(zyx)', 'b', 'c']\n"
] | f_14182339 | match multiple regex patterns with the alternation operator `|` in a string `(zyx)bc` | [
"re"
] |
|
7,126,916 | def f_7126916(elements):
|
return elements | elements = ['%{0}%'.format(element) for element in elements] |
def check(candidate): | [
"\n elements = ['abc', 'def', 'ijk', 'mno']\n assert candidate(elements) == ['%abc%', '%def%', '%ijk%', '%mno%']\n",
"\n elements = [1, 2, 3, 4, 500]\n assert candidate(elements) == ['%1%', '%2%', '%3%', '%4%', '%500%']\n"
] | f_7126916 | formate each string cin list `elements` into pattern '%{0}%' | [] |
3,595,685 | def f_3595685():
return | subprocess.Popen(['background-process', 'arguments']) |
import subprocess
from unittest.mock import Mock
def check(candidate): | [
"\n subprocess.Popen = Mock(return_value = 0)\n assert candidate() == 0\n"
] | f_3595685 | Open a background process 'background-process' with arguments 'arguments' | [
"subprocess"
] |
|
18,453,566 | def f_18453566(mydict, mykeys):
return | [mydict[x] for x in mykeys] |
def check(candidate): | [
"\n mydict = {'one': 1, 'two': 2, 'three': 3}\n mykeys = ['three', 'one']\n assert candidate(mydict, mykeys) == [3, 1]\n",
"\n mydict = {'one': 1.0, 'two': 2.0, 'three': 3.0}\n mykeys = ['one']\n assert candidate(mydict, mykeys) == [1.0]\n"
] | f_18453566 | get list of values from dictionary 'mydict' w.r.t. list of keys 'mykeys' | [] |
|
12,692,135 | def f_12692135():
return | dict([('Name', 'Joe'), ('Age', 22)]) |
def check(candidate): | [
"\n assert candidate() == {'Name': 'Joe', 'Age': 22}\n"
] | f_12692135 | convert list `[('Name', 'Joe'), ('Age', 22)]` into a dictionary | [] |
|
14,401,047 | def f_14401047(data):
return | data.mean(axis=1).reshape(data.shape[0], -1) |
import numpy as np
def check(candidate): | [
"\n data = np.array([[1, 2, 3, 4, 4, 3, 7, 1], [6, 2, 3, 4, 3, 4, 4, 1]])\n expected_res = np.array([[3.125], [3.375]])\n assert np.array_equal(candidate(data), expected_res)\n"
] | f_14401047 | average each two columns of array `data` | [
"numpy"
] |
|
18,886,596 | def f_18886596(s):
return | s.replace('"', '\"') |
def check(candidate): | [
"\n s = 'This sentence has some \"quotes\" in it'\n assert candidate(s) == 'This sentence has some \\\"quotes\\\" in it'\n"
] | f_18886596 | double backslash escape all double quotes in string `s` | [] |
|
5,932,059 | def f_5932059(s):
return | re.split('(\\W+)', s) |
import re
def check(candidate): | [
"\n s = \"this is a\\nsentence\"\n assert candidate(s) == ['this', ' ', 'is', ' ', 'a', '\\n', 'sentence']\n"
] | f_5932059 | split a string `s` into a list of words and whitespace | [
"re"
] |
|
9,938,130 | def f_9938130(df):
return | df.plot(kind='barh', stacked=True) |
import pandas as pd
def check(candidate): | [
"\n data = [[1, 3], [2, 5], [4, 8]]\n df = pd.DataFrame(data, columns = ['a', 'b'])\n assert str(candidate(df)).split('(')[0] == 'AxesSubplot'\n"
] | f_9938130 | plotting stacked barplots on a panda data frame `df` | [
"pandas"
] |
|
35,945,473 | def f_35945473(myDictionary):
return | {i[1]: i[0] for i in list(myDictionary.items())} |
def check(candidate): | [
"\n assert candidate({'a' : 'b', 'c' : 'd'}) == {'b': 'a', 'd': 'c'}\n"
] | f_35945473 | reverse the keys and values in a dictionary `myDictionary` | [] |
|
30,729,735 | def f_30729735(myList):
return | [i for i, j in enumerate(myList) if 'how' in j.lower() or 'what' in j.lower()] |
def check(candidate): | [
"\n assert candidate(['abc', 'how', 'what', 'def']) == [1, 2]\n"
] | f_30729735 | finding the index of elements containing substring 'how' and 'what' in a list of strings 'myList'. | [] |
|
1,303,243 | def f_1303243(obj):
return | isinstance(obj, str) |
def check(candidate): | [
"\n assert candidate('python3') == True\n",
"\n assert candidate(1.23) == False\n"
] | f_1303243 | check if object `obj` is a string | [] |
|
1,303,243 | def f_1303243(o):
return | isinstance(o, str) |
def check(candidate): | [
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] | f_1303243 | check if object `o` is a string | [] |
|
1,303,243 | def f_1303243(o):
return | (type(o) is str) |
def check(candidate): | [
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] | f_1303243 | check if object `o` is a string | [] |
|
1,303,243 | def f_1303243(obj_to_test):
return | isinstance(obj_to_test, str) |
def check(candidate): | [
"\n assert candidate(\"hello\") == True\n",
"\n assert candidate(123) == False\n",
"\n assert candidate([]) == False\n",
"\n assert candidate({\"aa\", \"v\"}) == False\n",
"\n assert candidate(\"123\") == True\n"
] | f_1303243 | check if `obj_to_test` is a string | [] |
|
8,177,079 | def f_8177079(list1, list2):
|
return | list2.extend(list1) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append list `list1` to `list2` | [] |
8,177,079 | def f_8177079(mylog, list1):
|
return | list1.extend(mylog) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append list `mylog` to `list1` | [] |
8,177,079 | def f_8177079(a, c):
|
return | c.extend(a) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append list `a` to `c` | [] |
8,177,079 | def f_8177079(mylog, list1):
|
return | for line in mylog:
list1.append(line) |
def check(candidate): | [
"\n a, b = [1, 2, 3], [4, 5, 6]\n candidate(a, b)\n assert b == [4, 5, 6, 1, 2, 3]\n",
"\n a, c = [1, 2, 3], [7, 8, 9]\n candidate(a, c)\n assert c == [7, 8, 9, 1, 2, 3] \n",
"\n b = [4, 5, 6, 1, 2, 3]\n c = [7, 8, 9, 1, 2, 3] \n candidate(b, c)\n assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]\n"
] | f_8177079 | append items in list `mylog` to `list1` | [] |
4,126,227 | def f_4126227(a, b):
|
return | b.append((a[0][0], a[0][2])) |
def check(candidate): | [
"\n a = [(1,2,3),(4,5,6)]\n b = [(0,0)]\n candidate(a, b)\n assert(b == [(0, 0), (1, 3)])\n"
] | f_4126227 | append a tuple of elements from list `a` with indexes '[0][0] [0][2]' to list `b` | [] |
34,902,378 | def f_34902378(app):
|
return | app.config['SECRET_KEY'] = 'Your_secret_string' |
from flask import Flask
def check(candidate): | [
"\n app = Flask(\"test\")\n candidate(app)\n assert app.config['SECRET_KEY'] == 'Your_secret_string'\n"
] | f_34902378 | Initialize `SECRET_KEY` in flask config with `Your_secret_string ` | [
"flask"
] |
22,799,300 | def f_22799300(out):
return | pd.DataFrame(out.tolist(), columns=['out-1', 'out-2'], index=out.index) |
import numpy as np
import pandas as pd
from scipy import stats
def check(candidate): | [
"\n df = pd.DataFrame(dict(x=np.random.randn(100), y=np.repeat(list(\"abcd\"), 25)))\n out = df.groupby(\"y\").x.apply(stats.ttest_1samp, 0)\n test = pd.DataFrame(out.tolist())\n test.columns = ['out-1', 'out-2']\n test.index = out.index\n res = candidate(out)\n assert(test.equals(res))\n"
] | f_22799300 | unpack a series of tuples in pandas `out` into a DataFrame with column names 'out-1' and 'out-2' | [
"numpy",
"pandas",
"scipy"
] |