Datasets:
thisisanshgupta
/
Pycode

Dataset card Data Studio Files Community
text
stringlengths
0
828
return ret"
4957,"def is_instance_running(self, instance_id):
""""""Checks if the instance is up and running.
:param str instance_id: instance identifier
:return: bool - True if running, False otherwise
""""""
self._restore_from_storage(instance_id)
if self._start_failed:
raise Exception('is_instance_running for node %s: failing due to'
' previous errors.' % instance_id)
try:
v_m = self._qualified_name_to_vm(instance_id)
if not v_m:
raise Exception(""Can't find instance_id %s"" % instance_id)
except Exception:
log.error(traceback.format_exc())
raise
return v_m._power_state == 'Started'"
4958,"def _save_or_update(self):
""""""Save or update the private state needed by the cloud provider.
""""""
with self._resource_lock:
if not self._config or not self._config._storage_path:
raise Exception(""self._config._storage path is undefined"")
if not self._config._base_name:
raise Exception(""self._config._base_name is undefined"")
if not os.path.exists(self._config._storage_path):
os.makedirs(self._config._storage_path)
path = self._get_cloud_provider_storage_path()
with open(path, 'wb') as storage:
pickle.dump(self._config, storage, pickle.HIGHEST_PROTOCOL)
pickle.dump(self._subscriptions, storage,
pickle.HIGHEST_PROTOCOL)"
4959,"def split_iter(src, sep=None, maxsplit=None):
""""""Splits an iterable based on a separator, *sep*, a max of
*maxsplit* times (no max by default). *sep* can be:
* a single value
* an iterable of separators
* a single-argument callable that returns True when a separator is
encountered
``split_iter()`` yields lists of non-separator values. A separator will
never appear in the output.
>>> list(split_iter(['hi', 'hello', None, None, 'sup', None, 'soap', None]))
[['hi', 'hello'], ['sup'], ['soap']]
Note that ``split_iter`` is based on :func:`str.split`, so if
*sep* is ``None``, ``split()`` **groups** separators. If empty lists
are desired between two contiguous ``None`` values, simply use
``sep=[None]``:
>>> list(split_iter(['hi', 'hello', None, None, 'sup', None]))
[['hi', 'hello'], ['sup']]
>>> list(split_iter(['hi', 'hello', None, None, 'sup', None], sep=[None]))
[['hi', 'hello'], [], ['sup'], []]
Using a callable separator:
>>> falsy_sep = lambda x: not x
>>> list(split_iter(['hi', 'hello', None, '', 'sup', False], falsy_sep))
[['hi', 'hello'], [], ['sup'], []]
See :func:`split` for a list-returning version.
""""""
if not is_iterable(src):
raise TypeError('expected an iterable')
if maxsplit is not None:
maxsplit = int(maxsplit)
if maxsplit == 0:
yield [src]
return
if callable(sep):
sep_func = sep
elif not is_scalar(sep):
sep = frozenset(sep)
sep_func = lambda x: x in sep
else:
sep_func = lambda x: x == sep
cur_group = []
split_count = 0
for s in src:
if maxsplit is not None and split_count >= maxsplit:
sep_func = lambda x: False
if sep_func(s):
if sep is None and not cur_group:
# If sep is none, str.split() ""groups"" separators
# check the str.split() docs for more info
continue
split_count += 1
yield cur_group
cur_group = []
else: