from __future__ import absolute_import
from __future__ import division
from future import standard_library
+from future.utils import listitems, listvalues
standard_library.install_aliases()
from builtins import range
from builtins import object
# A WRITABLE block with its owner.closed() implies that it's
# size is <= KEEP_BLOCK_SIZE/2.
try:
- small_blocks = [b for b in list(self._bufferblocks.values()) if b.state() == _BufferBlock.WRITABLE and b.owner.closed()]
+ small_blocks = [b for b in listvalues(self._bufferblocks) if b.state() == _BufferBlock.WRITABLE and b.owner.closed()]
except AttributeError:
# Writable blocks without owner shouldn't exist.
raise UnownedBlockError()
self.repack_small_blocks(force=True, sync=True)
with self.lock:
- items = list(self._bufferblocks.items())
+ items = listitems(self._bufferblocks)
for k,v in items:
if v.state() != _BufferBlock.COMMITTED and v.owner:
from __future__ import absolute_import
+from future.utils import listitems, listvalues, viewkeys
from builtins import str
from past.builtins import basestring
from builtins import object
return writer
def check_dependencies(self):
- for path, orig_stat in list(self._dependencies.items()):
+ for path, orig_stat in listitems(self._dependencies):
if not S_ISREG(orig_stat[ST_MODE]):
raise errors.StaleWriterStateError("{} not file".format(path))
try:
if value == self._committed:
return
if value:
- for k,v in list(self._items.items()):
+ for k,v in listitems(self._items):
v.set_committed(True)
self._committed = True
else:
@synchronized
def __iter__(self):
"""Iterate over names of files and collections contained in this collection."""
- return iter(list(self._items.keys()))
+ return iter(viewkeys(self._items))
@synchronized
def __getitem__(self, k):
@synchronized
def keys(self):
"""Get a list of names of files and collections directly contained in this collection."""
- return list(self._items.keys())
+ return viewkeys(self._items)
@synchronized
def values(self):
"""Get a list of files and collection objects directly contained in this collection."""
- return list(self._items.values())
+ return listvalues(self._items)
@synchronized
def items(self):
"""Get a list of (name, object) tuples directly contained in this collection."""
- return list(self._items.items())
+ return listitems(self._items)
def exists(self, path):
"""Test if there is a file or collection at `path`."""
item.remove(pathcomponents[1])
def _clonefrom(self, source):
- for k,v in list(source.items()):
+ for k,v in listitems(source):
self._items[k] = v.clone(self, k)
def clone(self):
@synchronized
def flush(self):
"""Flush bufferblocks to Keep."""
- for e in list(self.values()):
+ for e in listvalues(self):
e.flush()
from __future__ import division
from future import standard_library
+from future.utils import listvalues
standard_library.install_aliases()
from past.builtins import basestring
from builtins import object
abort("cannot copy object {} of type {}".format(args.object_uuid, t))
# Clean up any outstanding temp git repositories.
- for d in list(local_repo_dir.values()):
+ for d in listvalues(local_repo_dir):
shutil.rmtree(d, ignore_errors=True)
# If no exception was thrown and the response does not have an
from __future__ import division
+from future.utils import listitems, listvalues
from builtins import str
from builtins import object
import argparse
Recursively get the total size of the collection
"""
size = 0
- for item in list(collection.values()):
+ for item in listvalues(collection):
if isinstance(item, arvados.collection.Collection) or isinstance(item, arvados.collection.Subcollection):
size += self._collection_size(item)
else:
def collection_file_paths(self, col, path_prefix='.'):
"""Return a list of file paths by recursively go through the entire collection `col`"""
file_paths = []
- for name, item in list(col.items()):
+ for name, item in listitems(col):
if isinstance(item, arvados.arvfile.ArvadosFile):
file_paths.append(os.path.join(path_prefix, name))
elif isinstance(item, arvados.collection.Subcollection):
locators.append(loc)
return locators
elif isinstance(item, arvados.collection.Collection):
- l = [self._datablocks_on_item(x) for x in list(item.values())]
+ l = [self._datablocks_on_item(x) for x in listvalues(item)]
# Fast list flattener method taken from:
# http://stackoverflow.com/questions/952914/making-a-flat-list-out-of-list-of-lists-in-python
return [loc for sublist in l for loc in sublist]
if not output.endswith('\n'):
stdout.write('\n')
- for sigcode, orig_handler in list(orig_signal_handlers.items()):
+ for sigcode, orig_handler in listitems(orig_signal_handlers):
signal.signal(sigcode, orig_handler)
if status != 0:
from __future__ import print_function
from __future__ import absolute_import
+from future.utils import listvalues
from builtins import object
import collections
import hashlib
return self._files
def all_files(self):
- return list(self._files.values())
+ return listvalues(self._files)
def size(self):
n = self._data_locators[-1]
manifest_text.extend([d.locator for d in self._data_locators])
manifest_text.extend([' '.join(["{}:{}:{}".format(seg.locator, seg.range_size, f.name.replace(' ', '\\040'))
for seg in f.segments])
- for f in list(self._files.values())])
+ for f in listvalues(self._files)])
return ' '.join(manifest_text) + '\n'
from __future__ import print_function
from __future__ import division
+from future.utils import viewkeys
from builtins import str
from builtins import range
import argparse
projects / arvados.git / commitdiff