def __next__(self):
"""
Return the next error node
"""
for child in self.children:
yield child
next(self.parent)
def iterunique(source, key):
# assume source is sorted
# first need to sort the data
it = iter(source)
hdr = next(it)
yield tuple(hdr)
# convert field selection into field indices
if key is None:
indices = range(len(hdr))
else:
indices = asindices(hdr, key)
# now use field indices to construct a _getkey function
# N.B., this may raise an exception on short rows, depending on
# the field selection
getkey = operator.itemgetter(*indices)
prev = next(it)
prev_key = getkey(prev)
prev_comp_ne = True
for curr in it:
curr_key = getkey(curr)
curr_comp_ne = curr_key != prev_key
if prev_comp_ne and curr_comp_ne:
yield tuple(prev)
prev = curr
prev_key = curr_key
prev_comp_ne = curr_comp_ne
# last one?
if prev_comp_ne:
yield prev
def _sparql_query_pattern_part(
self,
bind=None,
values=None,
indent=' ',
):
assert bind is None or isinstance(bind, dict)
assert values is None or (
isinstance(values, dict) and
isinstance(next(six.iterkeys(values)), Iterable) and
isinstance(next(six.itervalues(values)), Iterable)
)
res = ''
if values:
res = indent + self._sparql_values_part(values, indent) + '\n'
res += indent + self._sparql_triples_part(indent) + '\n'
if bind:
res += '%sFILTER(\n%s\n%s)\n' % (
indent,
' &&\n'.join([
'%s %s=%s' % (indent, k.n3(), self.curify(v))
for k, v in sorted(bind.items())
if k in self.vars_in_graph
]),
indent,
)
return res
def read_tss_anno(anno, gene_filter):
positions = {}
g_filter = []
c = 0
if gene_filter:
with open(gene_filter) as f:
for line in f:
line = line.rstrip()
word = line.split("\t")
g_filter.append(word[0])
with open(anno) as f:
next(f)
for line in f:
line = line.rstrip()
word = line.split("\t")
if word[1] == "MT": chrom = "chrM"
elif word[1] == "X": chrom = "chrX"
elif word[1] == "Y": chrom = "chrY"
elif word[1].isdigit(): chrom = "chr" + word[1]
if word[4] == "1":
strand = "+"
else:
strand = "-"
if g_filter:
if word[0] in g_filter:
positions[word[0]] = (chrom, int(word[2]), strand)
c += 1
else:
positions[word[0]] = (chrom, int(word[2]), strand)
c += 1
return positions
def window(iter, pre_size=1, post_size=1): """ Given an iterable, return a new iterable which yields triples of (pre, item, post), where pre and post are the items preceeding and following the item (or None if no such item is appropriate). pre and post will always be pre_size and post_size in length. >>> example = window(range(10), pre_size=2) >>> pre, item, post = next(example) >>> pre (None, None) >>> post (1,) >>> next(example) ((None, 0), 1, (2,)) >>> list(example)[-1] ((7, 8), 9, (None,)) """ pre_iter, iter = itertools.tee(iter) pre_iter = itertools.chain((None,) * pre_size, pre_iter) pre_iter = nwise(pre_iter, pre_size) post_iter, iter = itertools.tee(iter) post_iter = itertools.chain(post_iter, (None,) * post_size) post_iter = nwise(post_iter, post_size) next(post_iter, None) return six.moves.zip(pre_iter, iter, post_iter)
def test_pqueue_by_servicebus_client_iter_messages_simple(live_servicebus_config, partitioned_queue):
client = ServiceBusClient(
service_namespace=live_servicebus_config['hostname'],
shared_access_key_name=live_servicebus_config['key_name'],
shared_access_key_value=live_servicebus_config['access_key'],
debug=True)
queue_client = client.get_queue(partitioned_queue)
with queue_client.get_receiver(idle_timeout=5, mode=ReceiveSettleMode.PeekLock) as receiver:
with queue_client.get_sender() as sender:
for i in range(10):
message = Message("Iter message no. {}".format(i))
sender.send(message)
count = 0
for message in receiver:
print_message(message)
message.complete()
with pytest.raises(MessageAlreadySettled):
message.complete()
with pytest.raises(MessageAlreadySettled):
message.renew_lock()
count += 1
with pytest.raises(InvalidHandlerState):
next(receiver)
assert count == 10
def test_post_process_extensions_generator_response(self):
class Controller(object):
def index(self, req, pants=None):
return pants
controller = Controller()
resource = wsgi.Resource(controller)
called = []
def extension1(req):
yield
called.append(1)
def extension2(req):
yield
called.append(2)
yield 'foo'
ext1 = extension1(None)
next(ext1)
ext2 = extension2(None)
next(ext2)
response = resource.post_process_extensions([ext2, ext1],
None, None, {})
self.assertEqual(called, [2])
self.assertEqual(response, 'foo')
def select_map(self, latitude, longitude):
"""
Find and display a nearby track by latitude / longitude
The selection will favor a previously selected track in the nearby area
:param latitude
:type latitude float
:param longitude
:type longitude float
:returns the selected track, or None if there are no nearby tracks
:type Track
"""
if not latitude or not longitude:
return None
point = GeoPoint.fromPoint(latitude, longitude)
nearby_tracks = self.track_manager.find_nearby_tracks(point)
saved_tracks = self.get_pref_track_selections()
saved_nearby_tracks = [t for t in nearby_tracks if t.track_id in saved_tracks]
# select the saved nearby track or just a nearby track
track = next(iter(saved_nearby_tracks), None)
track = next(iter(nearby_tracks), None) if track is None else track
if self.track != track:
# only update the trackmap if it's changing
self._select_track(track)
return track
def readFile(self):
file = "/Users/molgenis/Documents/graduation_project/mendelianViolationFiles/mendelian_violation_allDiploid_Xadjusted.txt"
mother_DP = []
father_DP = []
child_DP = []
transmissionProbability = []
with open(file) as f:
next(f)
for line in f:
if line != "":
columns = line.split('\t')
mother_DP.append(columns[6])
father_DP.append(columns[10])
child_DP.append(columns[14])
transmissionProbability.append(columns[4])
else:
next(line)
self.countThresholdMother(mother_DP)
self.countThresholdFather(father_DP)
self.countThresholdChild(child_DP)
self.countTP(transmissionProbability)
def unmunch_all(self):
self.parse_aff()
with codecs.open(self.dic_path, "r", "utf-8") as fp:
next(fp) # Skip first line.
for line in fp:
line = line.split(u" ")[0]
self.apply_suffix(u"", line)
def getContents(self, group):
if not self._checkFsEndpointPath():
return
logger.debug("Scanning for posts (shallow) in: %s" %
self.fs_endpoint_path)
year_pattern = ShallowPostsSource.YEAR_PATTERN
file_pattern = ShallowPostsSource.FILE_PATTERN
_, year_dirs, __ = next(osutil.walk(self.fs_endpoint_path))
year_dirs = [d for d in year_dirs if year_pattern.match(d)]
for yd in year_dirs:
if year_pattern.match(yd) is None:
logger.warning(
"'%s' is not formatted as 'YYYY' and will be ignored. "
"Is that a typo?")
continue
year = int(yd)
year_dir = os.path.join(self.fs_endpoint_path, yd)
_, __, filenames = next(osutil.walk(year_dir))
for f in filenames:
match = file_pattern.match(f)
if match is None:
name, ext = os.path.splitext(f)
logger.warning(
"'%s' is not formatted as 'MM-DD_slug-title.%s' "
"and will be ignored. Is that a typo?" % (f, ext))
continue
yield self._makeContentItem(
os.path.join(yd, f),
match.group(3),
year,
int(match.group(1)),
int(match.group(2)))
def get_apreture_dic():
ffline = ff.FortranRecordReader('(3X,a16,3I4,F17.4,F17.10,2F12.3,I4,2x,a16)')
dic = {}
with open(MIX_FILE) as f:
for _ in range(31):
next(f)
# for i in range(LAST_RING_ELEMENT):
while True:
try:
line = f.readline()
if not line:
break
hh = ffline.read(line)
device_type = int(hh[2])
if device_type == 2:
# this is a drift space, ignore it
continue
# name = 'DRIFT'
else:
name = hh[0].strip()
aperture = hh[6]
if name not in dic:
dic.update({name: aperture})
# print('{},\t{},\t,{}\n'.format(name, device_type, aperture))
# if aperture == 0:
# print(name)
except:
pass
return dic
def load_transactions_mock(input_file, **kwargs):
""" Mock for apyori.load_transactions. """
eq_(kwargs['delimiter'], delimiter)
eq_(next(input_file), inputs[0])
yield iter(input_transactions[0])
eq_(next(input_file), inputs[1])
yield iter(input_transactions[1])
async def async_step_import(self, user_input):
"""Import a config entry."""
if self.hass.config_entries.async_entries(DOMAIN):
return self.async_abort(reason='already_setup')
self._scan_interval = user_input[KEY_SCAN_INTERVAL]
if user_input[CONF_HOST] != DOMAIN:
self._hosts.append(user_input[CONF_HOST])
if not await self.hass.async_add_executor_job(
os.path.isfile, self.hass.config.path(TELLDUS_CONFIG_FILE)):
return await self.async_step_user()
conf = await self.hass.async_add_executor_job(
load_json, self.hass.config.path(TELLDUS_CONFIG_FILE))
host = next(iter(conf))
if user_input[CONF_HOST] != host:
return await self.async_step_user()
host = CLOUD_NAME if host == 'tellduslive' else host
return self.async_create_entry(
title=host,
data={
CONF_HOST: host,
KEY_SCAN_INTERVAL: self._scan_interval.seconds,
KEY_SESSION: next(iter(conf.values())),
})
def sepLine2List(file2sep, sep="-"):
"""
:param file:
default:combine
"""
try:
fhIn = open(file2sep,'r')
all = set()
for line in fhIn:
if line == '':
next()
line = line.replace(sep,'\n').rstrip()
line = line.split('\n')
for i in line:
all.add(i)
fhIn.close()
fhOut = open(file2sep+'_sep','w')
for i in all:
fhOut.write(i+'\n')
fhOut.close()
print("Entry number left: %s" % len(all))
except:
print "error in sepLine2List"
return False
def test_pubsub(self):
check_pubsub = self.redis.pubsub()
check_pubsub.psubscribe("gottwall:*")
next(check_pubsub.listen())
cli = RedisClient(
private_key=private_key,
public_key=public_key,
project=project,
host=HOST)
ts = datetime.utcnow()
self.assertEquals("gottwall:{0}:{1}:{2}".format(project, public_key, private_key), cli.channel)
cli.incr(name="orders", value=2, timestamp=ts, filters={"current_status": "Completed"})
message = next(check_pubsub.listen())
self.assertEquals(message['channel'], 'gottwall:{0}:{1}:{2}'.format(project, public_key, private_key))
notification_message = json.loads(message['data'])
self.assertEquals(notification_message['type'], 'notification')
data_dict = json.loads(self.redis.spop(cli.data_key))
self.assertTrue(data_dict['name'], 'orders')
self.assertTrue(data_dict['timestamp'], ts.strftime("%Y-%m-%dT%H:%M:%S"))
self.assertTrue(data_dict['filters']['current_status'], 'Completed')
self.assertEquals(self.redis.scard(cli.data_key), 0)
def __memory_info(self):
# Get all memory info and get details with 20 depth
size_obj = asizeof.asized(self._node, detail=20)
whole_size = size_obj.size
size_obj = next(r for r in size_obj.refs if r.name == '__dict__')
size_dict = dict()
# Sort in descending order to select most 'heavy' collections
for num, sub_obj in enumerate(sorted(size_obj.refs, key=lambda v: v.size, reverse=True)):
if num > 5:
break
size_dict[sub_obj.name] = dict()
size_dict[sub_obj.name]['size'] = sub_obj.size
# Check if this object (which include __dict__ and __class__) or iterable (dict, list, etc ..)
if len(sub_obj.refs) <= 2 and any(r.name == '__dict__' for r in sub_obj.refs):
sub_obj_ref = next(r for r in sub_obj.refs if r.name == '__dict__')
else:
sub_obj_ref = sub_obj
for num, sub_sub_obj in enumerate(sorted(sub_obj_ref.refs, key=lambda v: v.size, reverse=True)):
if num > 5:
break
size_dict[sub_obj.name][sub_sub_obj.name] = sub_sub_obj.size
result_dict = {"whole_node_size": whole_size}
result_dict.update(size_dict)
return {
'Memory': result_dict
}
def get_fluence(e_0=100.0):
"""
Returns a function representing the electron fluence with the distance in CSDA units.
Args:
e_0 (float): The kinetic energy whose CSDA range is used to scale the distances.
Returns:
A function representing fluence(x,u) with x in CSDA units.
"""
# List of available energies
e0_str_list = list(map(lambda x: (os.path.split(x)[1]).split(".csv")[
0], glob(os.path.join(data_path, "fluence", "*.csv"))))
e0_list = sorted(list(map(int, list(filter(str.isdigit, e0_str_list)))))
e_closest = min(e0_list, key=lambda x: abs(x - e_0))
with open(os.path.join(data_path, "fluence/grid.csv"), 'r') as csvfile:
r = csv.reader(csvfile, delimiter=' ', quotechar='|',
quoting=csv.QUOTE_MINIMAL)
t = next(r)
x = np.array([float(a) for a in t[0].split(",")])
t = next(r)
u = np.array([float(a) for a in t[0].split(",")])
t = []
with open(os.path.join(data_path, "fluence", "".join([str(e_closest), ".csv"])), 'r') as csvfile:
r = csv.reader(csvfile, delimiter=' ', quotechar='|',
quoting=csv.QUOTE_MINIMAL)
for row in r:
t.append([float(a) for a in row[0].split(",")])
t = np.array(t)
f = interpolate.RectBivariateSpline(x, u, t, kx=1, ky=1)
# Note f is returning numpy 1x1 arrays
return f
def _remove_sig(signature):
"""
Remove the signature node from payload keeping any tail element.
This is needed for eneveloped signatures.
:param payload: Payload to remove signature from
:type data: XML ElementTree Element
:param signature: Signature to remove from payload
:type digest_algorithm: XML ElementTree Element
"""
try:
signaturep = next(signature.iterancestors())
except StopIteration:
raise ValueError("Can't remove the root signature node")
if signature.tail is not None:
try:
signatures = next(signature.itersiblings(preceding=True))
except StopIteration:
if signaturep.text is not None:
signaturep.text = signaturep.text + signature.tail
else:
signaturep.text = signature.tail
else:
if signatures.tail is not None:
signatures.tail = signatures.tail + signature.tail
else:
signatures.tail = signature.tail
signaturep.remove(signature)
def get_cs(e_0=100, z=74):
"""
Returns a function representing the scaled bremsstrahlung cross_section.
Args:
e_0 (float): The electron kinetic energy, used to scale u=e_e/e_0.
z (int): Atomic number of the material.
Returns:
A function representing cross_section(e_g,u) in mb/keV, with e_g in keV.
"""
# NOTE: Data is given for E0>1keV. CS values below this level should be used with caution.
# The default behaviour is to keep it constant
with open(os.path.join(data_path, "cs/grid.csv"), 'r') as csvfile:
r = csv.reader(csvfile, delimiter=' ', quotechar='|',
quoting=csv.QUOTE_MINIMAL)
t = next(r)
e_e = np.array([float(a) for a in t[0].split(",")])
log_e_e = np.log10(e_e)
t = next(r)
k = np.array([float(a) for a in t[0].split(",")])
t = []
with open(os.path.join(data_path, "cs/%d.csv" % z), 'r') as csvfile:
r = csv.reader(csvfile, delimiter=' ', quotechar='|',
quoting=csv.QUOTE_MINIMAL)
for row in r:
t.append([float(a) for a in row[0].split(",")])
t = np.array(t)
scaled = interpolate.RectBivariateSpline(log_e_e, k, t, kx=3, ky=1)
m_electron = 511
z2 = z * z
return lambda e_g, u: (u * e_0 + m_electron) ** 2 * z2 / (u * e_0 * e_g * (u * e_0 + 2 * m_electron)) * (
scaled(np.log10(u * e_0), e_g / (u * e_0)))
def test_select_best_intent_with_domain(self):
"""Test to make sure that best intent is working with domains."""
self.engine.register_domain('Domain1')
self.engine.register_domain('Domain2')
# Creating first intent domain
parser1 = IntentBuilder("Parser1").require("Entity1").build()
self.engine.register_intent_parser(parser1, domain='Domain1')
self.engine.register_entity("tree", "Entity1", domain='Domain1')
# Creating second intent domain
parser2 = IntentBuilder("Parser1").require("Entity2").build()
self.engine.register_intent_parser(parser2, domain="Domain2")
self.engine.register_entity("house", "Entity2", domain="Domain2")
utterance = "Entity1 Entity2 go to the tree house"
intents = self.engine.determine_intent(utterance, 2)
intent = next(intents)
assert intent
self.assertEqual(intent['intent_type'], 'Parser1')
intent = next(intents)
assert intent
self.assertEqual(intent['intent_type'], 'Parser1')
def load_athletes(filename):
assert(type(filename) == str and len(filename) > 0)
athletes = []
with open(filename) as csvfile:
athlete_data = csv.reader(csvfile)
next(csvfile, None)
for row in athlete_data:
if row[2] and row[3] and row[4]:
row[12] = [row[12], row[13].split(', ')]
del row[-1]
athletes.append(row)
"""
Loads athlete data from 'filename' into a list of tuples.
Returns a list of tuples of each athlete's attributes, where
the last element of each tuple is a list of events the athlete
competed in.
Hint: Use the csv module to read quoted fields correctly.
1. The header line is skipped
2. Rows are removed if missing a value for the age, height, or weight.
3. All trailing events are placed in a list in position EVENTS_COL
For example:
[...,
['Zhaoxu Zhang', "People's Republic of China",
'24', '221', '110', 'M', '11/18/1987',
'', '0', '0', '0', '0',
['Basketball', "Men's Basketball"]],
...
]
"""
return athletes
def autoscale_rule_create(cmd, client, autoscale_name, resource_group_name, condition,
scale, profile_name=DEFAULT_PROFILE_NAME, cooldown=5, source=None,
timegrain="avg 1m"):
from azure.mgmt.monitor.models import ScaleRule, ScaleAction, ScaleDirection
autoscale_settings = client.get(resource_group_name, autoscale_name)
profile = next(x for x in autoscale_settings.profiles if x.name == profile_name)
condition.metric_resource_uri = source or autoscale_settings.target_resource_uri
condition.statistic = timegrain.statistic
condition.time_grain = timegrain.time_grain
rule = ScaleRule(
metric_trigger=condition,
scale_action=ScaleAction(
direction=scale.direction,
type=scale.type,
cooldown='PT{}M'.format(cooldown),
value=scale.value)
)
profile.rules.append(rule)
autoscale_settings = client.create_or_update(resource_group_name, autoscale_name, autoscale_settings)
profile = next(x for x in autoscale_settings.profiles if x.name == profile_name)
# determine if there are unbalanced rules
scale_out_rule_count = len([x for x in profile.rules if x.scale_action.direction == ScaleDirection.increase])
scale_in_rule_count = len([x for x in profile.rules if x.scale_action.direction == ScaleDirection.decrease])
if scale_out_rule_count and not scale_in_rule_count:
logger.warning("Profile '%s' has rules to scale out but none to scale in. "
"Recommend creating at least 1 scale in rule.", profile_name)
elif scale_in_rule_count and not scale_out_rule_count:
logger.warning("Profile '%s' has rules to scale in but none to scale out. "
"Recommend creating at least 1 scale out rule.", profile_name)
return rule
def get_cols(self, lines):
"""Initialize the header Column objects from the table ``lines``.
Based on the previously set Header attributes find or create the column names.
Sets ``self.cols`` with the list of Columns. This list only includes the actual
requested columns after filtering by the include_names and exclude_names
attributes. See ``self.names`` for the full list.
:param lines: list of table lines
:returns: None
"""
start_line = _get_line_index(self.start_line, self.process_lines(lines))
if start_line is None:
# No header line so auto-generate names from n_data_cols
if self.names is None:
# Get the data values from the first line of table data to determine n_data_cols
try:
first_data_vals = next(self.data.get_str_vals())
except StopIteration:
raise InconsistentTableError('No data lines found so cannot autogenerate column names')
n_data_cols = len(first_data_vals)
self.names = [self.auto_format % i for i in range(1, n_data_cols+1)]
elif self.names is None:
# No column names supplied so read them from header line in table.
for i, line in enumerate(self.process_lines(lines)):
if i == start_line:
break
else: # No header line matching
raise ValueError('No header line found in table')
self.names = next(self.splitter([line]))
self._set_cols_from_names()
def is_fastq( fqpath ):
try:
next( SeqIO.parse( fqpath, 'fastq' ) )
return True
except:
print "{} is not a fastq file".format(fqpath)
return False
def decode_item(next, token):
if token == b'i':
# integer: "i" value "e"
data = int(next())
if next() != b'e':
raise ValueError
elif token == b's':
# string: "s" value (virtual tokens)
data = next()
# Strings in torrent file are defined as utf-8 encoded
try:
data = data.decode('utf-8')
except UnicodeDecodeError:
# The pieces field is a byte string, and should be left as such.
pass
elif token == b'l' or token == b'd':
# container: "l" (or "d") values "e"
data = []
tok = next()
while tok != b'e':
data.append(decode_item(next, tok))
tok = next()
if token == b'd':
data = dict(list(zip(data[0::2], data[1::2])))
else:
raise ValueError
return data
def test_bison_lalr_repr_automaton_lr0():
ex = grammar_examples.lr0.ex_minimal1
grammar = ex.grammar
automaton = compute_automaton(grammar)
assert repr(automaton) == '<Automaton with 4 states>'
assert repr(automaton._data) == '''
[<StateData #0 with 1 actions, 1 gotos
<bison.ItemSet #0, size 2
< $accept → • Root $eof ∥ >
< Root → • term ∥ >
>>, <StateData #1 with 1 actions, 0 gotos
<bison.ItemSet #1, size 1
< Root → term • ∥ { $eof } >
>>, <StateData #2 with 1 actions, 0 gotos
<bison.ItemSet #2, size 1
< $accept → Root • $eof ∥ >
>>, <StateData #3 with 2 actions, 0 gotos
<bison.ItemSet #3, size 1
< $accept → Root $eof • ∥ >
>>]
'''.strip().replace('•', _mdot).replace('∥', _parallel)
assert repr(automaton._data[0]._id) == '''
<StateId for <StateData #0 with 1 actions, 1 gotos
<bison.ItemSet #0, size 2
< $accept → • Root $eof ∥ >
< Root → • term ∥ >
>>>
'''.strip().replace('•', _mdot).replace('∥', _parallel)
assert repr(next(iter(automaton._data[0]._actions.values()))) == 'Shift(<state 1>)'
assert repr(next(iter(automaton._data[1]._actions.values()))) == 'Reduce(<rule 1>)'
assert repr(next(iter(automaton._data[0]._gotos.values()))) == 'Goto(<state 2>)'
def run(self, infile, label, outfile, existing=None):
existing_rows = {}
if existing:
with open(existing, 'rU') as csvfile:
reader = csv.reader(csvfile)
existing_rows = dict([(x[0], x[1:]) for x in reader])
with open(infile, 'rU') as csvfile:
reader = csv.reader(csvfile)
# Ignore the header
next(reader)
for file_name, true_val, pred_val in reader:
if existing and file_name not in existing_rows:
raise Exception(
"The file name ({0}) doesn't exist in the existing file.".format(file_name))
if not existing:
existing_rows[file_name] = ['', '']
existing_rows[file_name] = (
_combine_values(existing_rows[file_name][0], true_val, label),
_combine_values(existing_rows[file_name][1], pred_val, label)
)
with open(outfile, 'w') as csvfile:
writer = csv.writer(csvfile)
writer.writerow(['file_name', 'true', 'predicted'])
for k, v in existing_rows.items():
writer.writerow((k, *v))
def test_stratified_kfold_no_shuffle():
# Manually check that StratifiedKFold preserves the data ordering as much
# as possible on toy datasets in order to avoid hiding sample dependencies
# when possible
X, y = np.ones(4), [1, 1, 0, 0]
splits = StratifiedKFold(2).split(X, y)
train, test = next(splits)
assert_array_equal(test, [0, 2])
assert_array_equal(train, [1, 3])
train, test = next(splits)
assert_array_equal(test, [1, 3])
assert_array_equal(train, [0, 2])
X, y = np.ones(7), [1, 1, 1, 0, 0, 0, 0]
splits = StratifiedKFold(2).split(X, y)
train, test = next(splits)
assert_array_equal(test, [0, 1, 3, 4])
assert_array_equal(train, [2, 5, 6])
train, test = next(splits)
assert_array_equal(test, [2, 5, 6])
assert_array_equal(train, [0, 1, 3, 4])
# Check if get_n_splits returns the number of folds
assert_equal(5, StratifiedKFold(5).get_n_splits(X, y))
def get_single_if_any(iterable,
exception_on_multiple=Exception('More than one value '
'not allowed.')):
'''
Get the single item of `iterable`, if any.
If `iterable` has one item, return it. If it's empty, get `None`. If it has
more than one item, raise an exception. (Unless
`exception_on_multiple=None`.)
'''
assert isinstance(exception_on_multiple, Exception) or \
exception_on_multiple is None
iterator = iter(iterable)
try:
first_item = next(iterator)
except StopIteration:
return None
else:
if exception_on_multiple:
try:
second_item = next(iterator)
except StopIteration:
return first_item
else:
raise exception_on_multiple
else: # not exception_on_multiple
return first_item