neulab/odex huggingface dataset:
# filter dataframe `df` by values in column `A` that appear more than once
def f_29836836(df):
	return df.groupby('A').filter(lambda x: len(x) > 1)

import pandas as pd

def check(candidate):
    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

    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
# append each line in file `myfile` into a list
def f_2545397(myfile):
	return [x for x in myfile if x != '']

def check(candidate):
    with open('./tmp.txt', 'w') as fw: 
        for s in ["hello", "world", "!!!"]:
            fw.write(f"{s}\n")

    with open('./tmp.txt', 'r') as myfile:
        lines = candidate(myfile)
        assert isinstance(lines, list)
        assert len(lines) == 3
        assert lines[0].strip() == "hello"
# Get a list of integers `lst` from a file `filename.txt`
def f_2545397():
	lst = list(map(int, open('filename.txt').readlines()))
	return lst

import pandas as pd

def check(candidate):
    with open('./filename.txt', 'w') as fw: 
        for s in ["1", "2", "100"]:
            fw.write(f"{s}\n")

    assert candidate() == [1, 2, 100]
# add color bar with image `mappable` to plot `plt`
def f_35420052(plt, mappable, ax3):
	plt.colorbar(mappable=mappable, cax=ax3)
	return plt

import numpy as np
import matplotlib.pyplot as plt
from obspy.core.trace import Trace
from obspy.imaging.spectrogram import spectrogram

def check(candidate):
    spl1 = Trace(data=np.arange(0, 10))
    fig = plt.figure()
    ax1 = fig.add_axes([0.1, 0.75, 0.7, 0.2]) #[left bottom width height]
    ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.60], sharex=ax1)
    ax3 = fig.add_axes([0.83, 0.1, 0.03, 0.6])

    #make time vector
    t = np.arange(spl1.stats.npts) / spl1.stats.sampling_rate

    #plot waveform (top subfigure)    
    ax1.plot(t, spl1.data, 'k')

    #plot spectrogram (bottom subfigure)
    spl2 = spl1
    fig = spl2.spectrogram(show=False, axes=ax2, wlen=10)
    mappable = ax2.images[0]
    candidate(plt, mappable, ax3)
    
    im=ax2.images
    assert im[-1].colorbar is not None
# count most frequent 100 words in column 'text' of dataframe `df`
def f_29903025(df):
	return Counter(' '.join(df['text']).split()).most_common(100)

import pandas as pd
from collections import Counter
 
def check(candidate):
    df = pd.DataFrame({"text": [
      'Python is a high-level, general-purpose programming language.', 
      'Its design philosophy emphasizes code readability with the use of significant indentation. Python is dynamically-typed and garbage-collected.'
    ]})
    assert candidate(df) == [('Python', 2),('is', 2),('a', 1),('high-level,', 1),('general-purpose', 1),
        ('programming', 1),('language.', 1),('Its', 1),('design', 1),('philosophy', 1),('emphasizes', 1),
        ('code', 1),('readability', 1),('with', 1), ('the', 1),('use', 1),('of', 1),('significant', 1),
        ('indentation.', 1),('dynamically-typed', 1),('and', 1),('garbage-collected.', 1)]
# generate all 2-element subsets of tuple `(1, 2, 3)`
def f_7378180():
	return list(itertools.combinations((1, 2, 3), 2))

import itertools

def check(candidate):
    assert candidate() == [(1, 2), (1, 3), (2, 3)]
# get a value of datetime.today() in the UTC time zone
def f_4530069():
	return datetime.now(pytz.utc)

import pytz
import time
from datetime import datetime, timezone

def check(candidate):
    assert (candidate() - datetime(1970, 1, 1).replace(tzinfo=timezone.utc)).total_seconds() - time.time() <= 1
# Get a new list `list2`by removing empty list from a list of lists `list1`
def f_4842956(list1):
	list2 = [x for x in list1 if x != []]
	return list2

def check(candidate):
    assert candidate([["a"], [], ["b"]]) == [["a"], ["b"]]

    assert candidate([[], [1,2,3], [], ["b"]]) == [[1,2,3], ["b"]]
# Create `list2` to contain the lists from list `list1` excluding the empty lists from `list1`
def f_4842956(list1):
	list2 = [x for x in list1 if x]
	return list2

def check(candidate):
    assert candidate([["a"], [], ["b"]]) == [["a"], ["b"]]

    assert candidate([[], [1,2,3], [], ["b"]]) == [[1,2,3], ["b"]]
# Django response with JSON `data`
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):
    if settings.DEBUG:
        assert candidate(json.dumps({"Sample-Key": "Sample-Value"})).content == b'{"Sample-Key": "Sample-Value"}'

    if settings.DEBUG:
        assert candidate(json.dumps({"Sample-Key": "Sample-Value"}))['content-type'] == 'application/json'
# get all text that is not enclosed within square brackets in string `example_str`
def f_17284947(example_str):
	return re.findall('(.*?)\\[.*?\\]', example_str)

import re 

def check(candidate):  
    list_elems = candidate("Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]")
    assert "".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'
# Use a regex to get all text in a string `example_str` that is not surrounded by square brackets
def f_17284947(example_str):
	return re.findall('(.*?)(?:\\[.*?\\]|$)', example_str)

import re 

def check(candidate): 
    list_elems = candidate("Josie Smith [3996 COLLEGE AVENUE, SOMETOWN, MD 21003]Mugsy Dog Smith [2560 OAK ST, GLENMEADE, WI 14098]")
    assert "".join(list_elems).strip() == 'Josie Smith Mugsy Dog Smith'
# get whatever is between parentheses as a single match, and any char outside as an individual match in string '(zyx)bc'
def f_14182339():
	return re.findall('\\(.+?\\)|\\w', '(zyx)bc')

import re 

def check(candidate):    
    assert candidate() == ['(zyx)', 'b', 'c']
# match regex '\\((.*?)\\)|(\\w)' with string '(zyx)bc'
def f_14182339():
	return re.findall('\\((.*?)\\)|(\\w)', '(zyx)bc')

import re 

def check(candidate): 
    assert candidate() == [('zyx', ''), ('', 'b'), ('', 'c')]
# match multiple regex patterns with the alternation operator `|` in a string `(zyx)bc`
def f_14182339():
	return re.findall('\\(.*?\\)|\\w', '(zyx)bc')

import re 

def check(candidate): 
    assert candidate() == ['(zyx)', 'b', 'c']
# formate each string cin list `elements` into pattern '%{0}%'
def f_7126916(elements):
	elements = ['%{0}%'.format(element) for element in elements]
	return elements

def check(candidate): 
    elements = ['abc', 'def', 'ijk', 'mno']
    assert candidate(elements) == ['%abc%', '%def%', '%ijk%', '%mno%']

    elements = [1, 2, 3, 4, 500]
    assert candidate(elements) == ['%1%', '%2%', '%3%', '%4%', '%500%']
# Open a background process 'background-process' with arguments 'arguments'
def f_3595685():
	return subprocess.Popen(['background-process', 'arguments'])

import subprocess
from unittest.mock import Mock

def check(candidate):
    subprocess.Popen = Mock(return_value = 0)
    assert candidate() == 0
# get list of values from dictionary 'mydict' w.r.t. list of keys 'mykeys'
def f_18453566(mydict, mykeys):
	return [mydict[x] for x in mykeys]

def check(candidate):
    mydict = {'one': 1, 'two': 2, 'three': 3}
    mykeys = ['three', 'one']
    assert candidate(mydict, mykeys) == [3, 1]

    mydict = {'one': 1.0, 'two': 2.0, 'three': 3.0}
    mykeys = ['one']
    assert candidate(mydict, mykeys) == [1.0]
# convert list `[('Name', 'Joe'), ('Age', 22)]` into a dictionary
def f_12692135():
	return dict([('Name', 'Joe'), ('Age', 22)])

def check(candidate):
    assert candidate() == {'Name': 'Joe', 'Age': 22}
# average each two columns of array `data`
def f_14401047(data):
	return data.mean(axis=1).reshape(data.shape[0], -1)

import numpy as np

def check(candidate):
    data = np.array([[1, 2, 3, 4, 4, 3, 7, 1], [6, 2, 3, 4, 3, 4, 4, 1]])
    expected_res = np.array([[3.125], [3.375]])
    assert np.array_equal(candidate(data), expected_res)
# double backslash escape all double quotes in string `s`
def f_18886596(s):
	return s.replace('"', '\"')

def check(candidate):
    s = 'This sentence has some "quotes" in it'
    assert candidate(s) == 'This sentence has some \"quotes\" in it'
# split a string `s` into a list of words and whitespace
def f_5932059(s):
	return re.split('(\\W+)', s)

import re 

def check(candidate):
    s = "this is  a\nsentence"
    assert candidate(s) == ['this', ' ', 'is', '  ', 'a', '\n', 'sentence']
# plotting stacked barplots on a panda data frame `df`
def f_9938130(df):
	return df.plot(kind='barh', stacked=True)

import pandas as pd

def check(candidate):
    data = [[1, 3], [2, 5], [4, 8]]
    df = pd.DataFrame(data, columns = ['a', 'b'])
    assert str(candidate(df)).split('(')[0] == 'AxesSubplot'
# reverse the keys and values in a dictionary `myDictionary`
def f_35945473(myDictionary):
	return {i[1]: i[0] for i in list(myDictionary.items())}

def check(candidate):
    assert candidate({'a' : 'b', 'c' : 'd'}) == {'b': 'a', 'd': 'c'}
# finding the index of elements containing substring 'how' and 'what' in a list of strings 'myList'.
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):
    assert candidate(['abc', 'how', 'what', 'def']) == [1, 2]
# check if object `obj` is a string
def f_1303243(obj):
	return isinstance(obj, str)

def check(candidate):
    assert candidate('python3') == True

    assert candidate(1.23) == False
# check if object `o` is a string
def f_1303243(o):
	return isinstance(o, str)

def check(candidate):
    assert candidate("hello") == True

    assert candidate(123) == False

    assert candidate([]) == False

    assert candidate({"aa", "v"}) == False

    assert candidate("123") == True
# check if object `o` is a string
def f_1303243(o):
	return (type(o) is str)

def check(candidate):
    assert candidate("hello") == True

    assert candidate(123) == False

    assert candidate([]) == False

    assert candidate({"aa", "v"}) == False

    assert candidate("123") == True
# check if `obj_to_test` is a string
def f_1303243(obj_to_test):
	return isinstance(obj_to_test, str)

def check(candidate):
    assert candidate("hello") == True

    assert candidate(123) == False

    assert candidate([]) == False

    assert candidate({"aa", "v"}) == False

    assert candidate("123") == True
# append list `list1` to `list2`
def f_8177079(list1, list2):
	list2.extend(list1)
	return 

def check(candidate):
    a, b = [1, 2, 3], [4, 5, 6]
    candidate(a, b)
    assert b == [4, 5, 6, 1, 2, 3]

    a, c = [1, 2, 3], [7, 8, 9]
    candidate(a, c)
    assert c == [7, 8, 9, 1, 2, 3] 

    b = [4, 5, 6, 1, 2, 3]
    c = [7, 8, 9, 1, 2, 3] 
    candidate(b, c)
    assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]
# append list `mylog` to `list1`
def f_8177079(mylog, list1):
	list1.extend(mylog)
	return 

def check(candidate):
    a, b = [1, 2, 3], [4, 5, 6]
    candidate(a, b)
    assert b == [4, 5, 6, 1, 2, 3]

    a, c = [1, 2, 3], [7, 8, 9]
    candidate(a, c)
    assert c == [7, 8, 9, 1, 2, 3] 

    b = [4, 5, 6, 1, 2, 3]
    c = [7, 8, 9, 1, 2, 3] 
    candidate(b, c)
    assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]
# append list `a` to `c`
def f_8177079(a, c):
	c.extend(a)
	return 

def check(candidate):
    a, b = [1, 2, 3], [4, 5, 6]
    candidate(a, b)
    assert b == [4, 5, 6, 1, 2, 3]

    a, c = [1, 2, 3], [7, 8, 9]
    candidate(a, c)
    assert c == [7, 8, 9, 1, 2, 3] 

    b = [4, 5, 6, 1, 2, 3]
    c = [7, 8, 9, 1, 2, 3] 
    candidate(b, c)
    assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]
# append items in list `mylog` to `list1`
def f_8177079(mylog, list1):
	for line in mylog:
	    list1.append(line)
	return 

def check(candidate):
    a, b = [1, 2, 3], [4, 5, 6]
    candidate(a, b)
    assert b == [4, 5, 6, 1, 2, 3]

    a, c = [1, 2, 3], [7, 8, 9]
    candidate(a, c)
    assert c == [7, 8, 9, 1, 2, 3] 

    b = [4, 5, 6, 1, 2, 3]
    c = [7, 8, 9, 1, 2, 3] 
    candidate(b, c)
    assert c == [7, 8, 9, 1, 2, 3, 4, 5, 6, 1, 2, 3]
# append a tuple of elements from list `a` with indexes '[0][0] [0][2]' to list `b`
def f_4126227(a, b):
	b.append((a[0][0], a[0][2]))
	return 

def check(candidate):
    a = [(1,2,3),(4,5,6)]
    b = [(0,0)]
    candidate(a, b)
    assert(b == [(0, 0), (1, 3)])
# Initialize `SECRET_KEY` in flask config with `Your_secret_string `
def f_34902378(app):
	app.config['SECRET_KEY'] = 'Your_secret_string'
	return 

from flask import Flask

def check(candidate):
    app = Flask("test")
    candidate(app)
    assert app.config['SECRET_KEY'] == 'Your_secret_string'
# unpack a series of tuples in pandas `out` into a DataFrame with column names 'out-1' and 'out-2'
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):
    df = pd.DataFrame(dict(x=np.random.randn(100), y=np.repeat(list("abcd"), 25)))
    out = df.groupby("y").x.apply(stats.ttest_1samp, 0)
    test = pd.DataFrame(out.tolist())
    test.columns = ['out-1', 'out-2']
    test.index = out.index
    res = candidate(out)
    assert(test.equals(res))
# find the index of an element 'MSFT' in a list `stocks_list`
def f_1762484(stocks_list):
	return [x for x in range(len(stocks_list)) if stocks_list[x] == 'MSFT']

def check(candidate):
    stocks_list = ['AAPL', 'MSFT', 'GOOG', 'MSFT', 'MSFT']
    assert(candidate(stocks_list) == [1,3,4])

    stocks_list = ['AAPL', 'MSXT', 'GOOG', 'MSAT', 'SFT']
    assert(candidate(stocks_list) == [])
# rotate the xtick `labels` of matplotlib plot `ax` by `45` degrees to make long labels readable
def f_3464359(ax, labels):
	return ax.set_xticklabels(labels, rotation=45)

import matplotlib.pyplot as plt 

def check(candidate):
    fig, ax = plt.subplots()
    ax.plot([1, 2, 3, 4], [1, 4, 2, 3])
    ret = candidate(ax, [f"#{i}" for i in range(7)])
    assert [tt.get_rotation() == 45.0 for tt in ret]
# remove symbols from a string `s`
def f_875968(s):
	return re.sub('[^\\w]', ' ', s)

import re

def check(candidate):
    s = "how much for the maple syrup? $20.99? That's ridiculous!!!"
    assert candidate(s) == 'how much for the maple syrup   20 99  That s ridiculous   '
# Find octal characters matches from a string `s` using regex
def f_34750084(s):
	return re.findall("'\\\\[0-7]{1,3}'", s)

import re

def check(candidate):
    assert candidate(r"char x = '\077';") == ["'\\077'"]
# split string `input` based on occurrences of regex pattern '[ ](?=[A-Z]+\\b)'
def f_13209288(input):
	return re.split(r'[ ](?=[A-Z]+\b)', input)

import re

def check(candidate):
    assert candidate('HELLO there HOW are YOU') == ['HELLO there', 'HOW are', 'YOU']

    assert candidate('hELLO there HoW are YOU') == ['hELLO there HoW are', 'YOU']

    assert candidate('7 is a NUMBER') == ['7 is a', 'NUMBER']

    assert candidate('NUMBER 7') == ['NUMBER 7']
# Split string `input` at every space followed by an upper-case letter
def f_13209288(input):
	return re.split('[ ](?=[A-Z])', input)

import re

def check(candidate):
    assert candidate('HELLO there HOW are YOU') == ['HELLO there', 'HOW are', 'YOU']

    assert candidate('hELLO there HoW are YOU') == ['hELLO there', 'HoW are', 'YOU']

    assert candidate('7 is a NUMBER') == ['7 is a', 'NUMBER']

    assert candidate('NUMBER 7') == ['NUMBER 7']
# send multipart encoded file `files` to url `url` with headers `headers` and metadata `data`
def f_24642040(url, files, headers, data):
	return requests.post(url, files=files, headers=headers, data=data)

import requests
from unittest.mock import Mock

def check(candidate):
    requests.post = Mock()
    try:
        candidate('https://www.google.com', ['a.txt'], {'accept': 'text/json'}, {'name': 'abc'})
    except:
        assert False
# write bytes `bytes_` to a file `filename` in python 3
def f_4290716(filename, bytes_):
	return open(filename, 'wb').write(bytes_)

def check(candidate):
    bytes_ = b'68 65 6c 6c 6f'
    candidate("tmpfile", bytes_)

    with open("tmpfile", 'rb') as fr:
        assert fr.read() == bytes_
# get a list from a list `lst` with values mapped into a dictionary `dct`
def f_33078554(lst, dct):
	return [dct[k] for k in lst]

def check(candidate):
    assert candidate(['c', 'd', 'a', 'b', 'd'], {'a': '3', 'b': '3', 'c': '5', 'd': '3'}) == ['5', '3', '3', '3', '3'] 

    assert candidate(['c', 'd', 'a', 'b', 'd'], {'a': 3, 'b': 3, 'c': 5, 'd': 3}) == [5, 3, 3, 3, 3] 

    assert candidate(['c', 'd', 'a', 'b'], {'a': 3, 'b': 3, 'c': 5, 'd': 3}) == [5, 3, 3, 3]
# find duplicate names in column 'name' of the dataframe `x`
def f_15247628(x):
	return x['name'][x.duplicated('name')]

import pandas as pd 

def check(candidate): 
    assert candidate(pd.DataFrame([{'name': 'willy', 'age': 10}, {'name': 'wilson', 'age': 11}, {'name': 'zoe', 'age': 10}])).tolist() == [] 

    assert candidate(pd.DataFrame([{'name': 'willy', 'age': 10}, {'name': 'willy', 'age': 11}, {'name': 'zoe', 'age': 10}])).tolist() == ['willy'] 

    assert candidate(pd.DataFrame([{'name': 'willy', 'age': 11}, {'name': 'willy', 'age': 11}, {'name': 'zoe', 'age': 10}])).tolist() == ['willy'] 

    assert candidate(pd.DataFrame([{'name': 'Willy', 'age': 11}, {'name': 'willy', 'age': 11}, {'name': 'zoe', 'age': 10}])).tolist() == []
# truncate float 1.923328437452 to 3 decimal places
def f_783897():
	return round(1.923328437452, 3)

def check(candidate): 
    assert candidate() == 1.923
# sort list `li` in descending order based on the date value in second element of each list in list `li`
def f_22859493(li):
	return sorted(li, key=lambda x: datetime.strptime(x[1], '%d/%m/%Y'), reverse=True)

from datetime import datetime

def check(candidate): 
    assert candidate([['name', '01/03/2012', 'job'], ['name', '02/05/2013', 'job'], ['name', '03/08/2014', 'job']]) == [['name', '03/08/2014', 'job'], ['name', '02/05/2013', 'job'], ['name', '01/03/2012', 'job']] 

    assert candidate([['name', '01/03/2012', 'job'], ['name', '02/05/2012', 'job'], ['name', '03/08/2012', 'job']]) == [['name', '03/08/2012', 'job'], ['name', '02/05/2012', 'job'], ['name', '01/03/2012', 'job']] 

    assert candidate([['name', '01/03/2012', 'job'], ['name', '02/03/2012', 'job'], ['name', '03/03/2012', 'job']]) == [['name', '03/03/2012', 'job'], ['name', '02/03/2012', 'job'], ['name', '01/03/2012', 'job']] 

    assert candidate([['name', '03/03/2012', 'job'], ['name', '03/03/2012', 'job'], ['name', '03/03/2012', 'job']]) == [['name', '03/03/2012', 'job'], ['name', '03/03/2012', 'job'], ['name', '03/03/2012', 'job']]
# place the radial ticks in plot `ax` at 135 degrees
def f_29394552(ax):
	ax.set_rlabel_position(135)
	return 

import matplotlib.pyplot as plt 

def check(candidate): 
    ax = plt.subplot(111, polar=True)
    candidate(ax)
    assert ax.properties()['rlabel_position'] == 135.0
# check if path `my_path` is an absolute path
def f_3320406(my_path):
	return os.path.isabs(my_path)

import os

def check(candidate): 
    assert candidate('.') == False 

    assert candidate('/') == True 

    assert candidate('/usr') == True
# get number of keys in dictionary `yourdict`
def f_2212433(yourdict):
	return len(list(yourdict.keys()))

def check(candidate): 
    assert candidate({'a': 1, 'b': 2, 'c': 3}) == 3 

    assert candidate({'a': 2, 'c': 3}) == 2
# count the number of keys in dictionary `yourdictfile`
def f_2212433(yourdictfile):
	return len(set(open(yourdictfile).read().split()))

def check(candidate): 
    with open('dict.txt', 'w') as fw:
        for w in ["apple", "banana", "tv", "apple", "phone"]:
            fw.write(f"{w}\n")
    assert candidate('dict.txt') == 4
# pandas dataframe `df` get first row of each group by 'id'
def f_20067636(df):
	return df.groupby('id').first()

import pandas as pd 

def check(candidate): 
    df = pd.DataFrame({
        'id': [1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 6, 6, 6, 7, 7], 
        'value': ['first', 'second', 'second', 'first', 'second', 'first', 'third', 'fourth', 'fifth', 'second', 'fifth', 'first', 'first', 'second', 'third', 'fourth', 'fifth']
    })
    assert candidate(df).to_dict() == {'value': {1: 'first', 2: 'first', 3: 'first', 4: 'second', 5: 'first', 6: 'first', 7: 'fourth'}}
# split a list in first column into multiple columns keeping other columns as well in pandas data frame `df`
def f_40924332(df):
	return pd.concat([df[0].apply(pd.Series), df[1]], axis=1)

import numpy as np
import pandas as pd 

def check(callerFunction):
    assert callerFunction(pd.DataFrame([[[8, 10, 12], 'A'], [[7, 9, 11], 'B']])).equals(pd.DataFrame([[8,10,12,'A'], [7,9,11,'B']], columns=[0,1,2,1]))

    assert callerFunction(pd.DataFrame([[[8, 10, 12], 'A'], [[7, 11], 'B']])).equals(pd.DataFrame([[8.0,10.0,12.0,'A'], [7.0,11.0,np.nan,'B']], columns=[0,1,2,1]))

    assert callerFunction(pd.DataFrame([[[8, 10, 12]], [[7, 9, 11], 'B']])).equals(pd.DataFrame([[8,10,12,None], [7,9,11,'B']], columns=[0,1,2,1]))
# extract attributes 'src="js/([^"]*\\bjquery\\b[^"]*)"' from string `data`
def f_30759776(data):
	return re.findall('src="js/([^"]*\\bjquery\\b[^"]*)"', data)

import re 

def check(candidate):
    data = '<script type="text/javascript" src="js/jquery-1.9.1.min.js"/><script type="text/javascript" src="js/jquery-migrate-1.2.1.min.js"/><script type="text/javascript" src="js/jquery-ui.min.js"/><script type="text/javascript" src="js/abc_bsub.js"/><script type="text/javascript" src="js/abc_core.js"/>            <script type="text/javascript" src="js/abc_explore.js"/><script type="text/javascript" src="js/abc_qaa.js"/>'
    assert candidate(data) == ['jquery-1.9.1.min.js', 'jquery-migrate-1.2.1.min.js', 'jquery-ui.min.js']
# Sum integers contained in strings in list `['', '3.4', '', '', '1.0']`
def f_25388796():
	return sum(int(float(item)) for item in [_f for _f in ['', '3.4', '', '', '1.0'] if _f])

def check(candidate):
    assert candidate() == 4
# Call a subprocess with arguments `c:\\Program Files\\VMware\\VMware Server\\vmware-cmd.bat` that may contain spaces
def f_804995():
	return subprocess.Popen(['c:\\Program Files\\VMware\\VMware Server\\vmware-cmd.bat'])

import subprocess
from unittest.mock import Mock

def check(candidate):
    subprocess.Popen = Mock(return_value = 0)
    assert candidate() == 0
# reverse a priority queue `q` in python without using classes
def f_26441253(q):
	for n in [1,3,4,2]: q.put((-n, n))
	return q

from queue import PriorityQueue

def check(candidate):
    q = PriorityQueue()
    q = candidate(q)
    expected = [4, 3, 2, 1]
    for i in range(0, len(expected)):
        assert q.get()[1] == expected[i]
# make a barplot of data in column `group` of dataframe `df` colour-coded according to list `color`
def f_18897261(df):
	return df['group'].plot(kind='bar', color=['r', 'g', 'b', 'r', 'g', 'b', 'r'])

import pandas as pd

def check(candidate):
    df = pd.DataFrame([1, 3, 4, 5, 7, 9], columns = ['group'])
    a = candidate(df)
    assert 'AxesSubplot' in str(type(a))
# find all matches of regex pattern '([a-fA-F\\d]{32})' in string `data`
def f_373194(data):
	return re.findall('([a-fA-F\\d]{32})', data)

import re 

def check(candidate):
    assert candidate('6f96cfdfe5ccc627cadf24b41725caa4 gorilla') ==         ['6f96cfdfe5ccc627cadf24b41725caa4']
# Get the length of list `my_list`
def f_518021(my_list):
	return len(my_list)

def check(candidate):
    assert candidate([]) == 0

    assert candidate([1]) == 1

    assert candidate([1, 2]) == 2
# Getting the length of array `l`
def f_518021(l):
	return len(l)

import numpy as np 

def check(candidate):
    assert candidate([]) == 0

    assert candidate(np.array([1])) == 1

    assert candidate(np.array([1, 2])) == 2
# Getting the length of array `s`
def f_518021(s):
	return len(s)

import numpy as np 

def check(candidate):
    assert candidate([]) == 0

    assert candidate(np.array([1])) == 1

    assert candidate(np.array([1, 2])) == 2
# Getting the length of `my_tuple`
def f_518021(my_tuple):
	return len(my_tuple)

def check(candidate):
    assert candidate(()) == 0

    assert candidate(('aa', 'wfseg', '')) == 3

    assert candidate(('apple',)) == 1