def _get_right_part(self, bar): right = bar.right if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' if self.fm.thisdir.filter: right.add(" f=`", base, 'filter') right.add(self.fm.thisdir.filter.pattern, base, 'filter') right.add("', ", "space") if target.marked_items: if len(target.marked_items) == len(target.files): right.add(human_readable(target.disk_usage, separator='')) else: sumsize = sum( f.size for f in target.marked_items if not f.is_directory or f._cumulative_size_calculated) right.add(human_readable(sumsize, separator='')) right.add("/" + str(len(target.marked_items))) else: right.add(human_readable(target.disk_usage, separator='') + " sum") try: free = get_free_space(target.mount_path) except OSError: pass else: right.add(", ", "space") right.add(human_readable(free, separator='') + " free") right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked') elif len(target.files): right.add( str(target.pointer + 1) + '/' + str(len(target.files)) + ' ', base) if max_pos <= 0: right.add('All', base, 'all') elif pos == 0: right.add('Top', base, 'top') elif pos >= max_pos: right.add('Bot', base, 'bot') else: right.add('{0:0>.0f}%'.format(100.0 * pos / max_pos), base, 'percentage') else: right.add('0/0 All', base, 'all')
def _get_right_part(self, bar): right = bar.right if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' if self.fm.thisdir.filter: right.add(" f=`", base, 'filter') right.add(self.fm.thisdir.filter.pattern, base, 'filter') right.add("', ", "space") if target.marked_items: if len(target.marked_items) == len(target.files): right.add(human_readable(target.disk_usage, separator='')) else: sumsize = sum(f.size for f in target.marked_items if not f.is_directory or f._cumulative_size_calculated) right.add(human_readable(sumsize, separator='')) right.add("/" + str(len(target.marked_items))) else: right.add(human_readable(target.disk_usage, separator='') + " sum") try: free = get_free_space(target.mount_path) except OSError: pass else: right.add(", ", "space") right.add(human_readable(free, separator='') + " free") right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked') elif len(target.files): right.add(str(target.pointer + 1) + '/' + str(len(target.files)) + ' ', base) if max_pos <= 0: right.add('All', base, 'all') elif pos == 0: right.add('Top', base, 'top') elif pos >= max_pos: right.add('Bot', base, 'bot') else: right.add('{0:0>.0f}%'.format(100.0 * pos / max_pos), base, 'percentage') else: right.add('0/0 All', base, 'all')
def _get_right_part(self, bar): right = bar.right if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' if self.env.cwd.filter: right.add(" f=", base, 'filter') right.add(repr(self.env.cwd.filter), base, 'filter') right.add(", ", "space") if target.marked_items: if len(target.marked_items) == len(target.files): right.add(human_readable(target.disk_usage, seperator='')) else: right.add(human_readable(sum(f.size \ for f in target.marked_items \ if f.is_file), seperator='')) right.add("/" + str(len(target.marked_items))) else: right.add( human_readable(target.disk_usage, seperator='') + " sum, ") right.add(human_readable(self.env.get_free_space( \ target.mount_path), seperator='') + " free") right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked') elif len(target.files): right.add( str(target.pointer + 1) + '/' + str(len(target.files)) + ' ', base) if max_pos == 0: right.add('All', base, 'all') elif pos == 0: right.add('Top', base, 'top') elif pos >= max_pos: right.add('Bot', base, 'bot') else: right.add('{0:0>.0f}%'.format(100.0 * pos / max_pos), base, 'percentage') else: right.add('0/0 All', base, 'all')
def _get_right_part(self, bar): right = bar.right if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' if self.env.cwd.filter: right.add(" f=", base, 'filter') right.add(repr(self.env.cwd.filter), base, 'filter') right.add(", ", "space") if target.marked_items: if len(target.marked_items) == len(target.files): right.add(human_readable(target.disk_usage, seperator='')) else: right.add(human_readable(sum(f.size \ for f in target.marked_items \ if f.is_file), seperator='')) right.add("/" + str(len(target.marked_items))) else: right.add(human_readable(target.disk_usage, seperator='') + " sum, ") right.add(human_readable(self.env.get_free_space( \ target.mount_path), seperator='') + " free") right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked') elif len(target.files): right.add(str(target.pointer + 1) + '/' + str(len(target.files)) + ' ', base) if max_pos == 0: right.add('All', base, 'all') elif pos == 0: right.add('Top', base, 'top') elif pos >= max_pos: right.add('Bot', base, 'bot') else: right.add('{0:0>.0f}%'.format(100.0 * pos / max_pos), base, 'percentage') else: right.add('0/0 All', base, 'all')
def generate(self): if not self.copy_buffer or len(self.copy_buffer) > 1: return from ranger.ext import shutil_generatorized as shutil_g # TODO: Don't calculate size when renaming (needs detection) bytes_per_tick = shutil_g.BLOCK_SIZE size = max(1, self._calculate_size(bytes_per_tick)) size_str = " (" + human_readable(self._calculate_size(1)) + ")" done = 0 self.description = "copying: " + self.one_file.path + size_str fobj = self.copy_buffer[0] if os.path.isdir(fobj.path) and not os.path.islink(fobj.path): n = 0 for n in shutil_g.copytree( src=fobj.path, dst=os.path.join(self.original_path, fobj.basename), symlinks=True, overwrite=self.overwrite, ): self.percent = ((done + n) / size) * 100. yield done += n else: n = 0 for n in shutil_g.copy2(fobj.path, self.original_path, symlinks=True, overwrite=self.overwrite): self.percent = ((done + n) / size) * 100. yield done += n cwd = self.fm.get_directory(self.original_path) cwd.load_content()
def infostring(self, fobj, metadata): if fobj.is_directory: dir_size = subprocess.getoutput('du -sh "{}"'.format( fobj.path)).split("\t")[0] return dir_size else: return human_readable(fobj.size)
def generate(self): from ranger.ext import shutil_generatorized as shutil_g if self.copy_buffer: # TODO: Don't calculate size when renaming (needs detection) bytes_per_tick = shutil_g.BLOCK_SIZE size = max(1, self._calculate_size(bytes_per_tick)) size_str = " (" + human_readable(self._calculate_size(1)) + ")" done = 0 if self.do_cut: self.original_copy_buffer.clear() if len(self.copy_buffer) == 1: self.description = "moving: " + self.one_file.path + size_str else: self.description = "moving files from: " + self.one_file.dirname + size_str for f in self.copy_buffer: for tf in self.fm.tags.tags: if tf == f.path or str(tf).startswith(f.path): tag = self.fm.tags.tags[tf] self.fm.tags.remove(tf) self.fm.tags.tags[tf.replace( f.path, self.original_path + '/' + f.basename)] = tag self.fm.tags.dump() d = 0 for d in shutil_g.move(src=f.path, dst=self.original_path, overwrite=self.overwrite): self.percent = float(done + d) / size * 100. yield done += d else: if len(self.copy_buffer) == 1: self.description = "copying: " + self.one_file.path + size_str else: self.description = "copying files from: " + self.one_file.dirname + size_str for f in self.copy_buffer: if os.path.isdir(f.path) and not os.path.islink(f.path): d = 0 for d in shutil_g.copytree(src=f.path, dst=os.path.join( self.original_path, f.basename), symlinks=True, overwrite=self.overwrite): self.percent = float(done + d) / size * 100. yield done += d else: d = 0 for d in shutil_g.copy2(f.path, self.original_path, symlinks=True, overwrite=self.overwrite): self.percent = float(done + d) / size * 100. yield done += d cwd = self.fm.get_directory(self.original_path) cwd.load_content()
def generate(self): if not self.copy_buffer: return from ranger.ext import shutil_generatorized as shutil_g # TODO: Don't calculate size when renaming (needs detection) bytes_per_tick = shutil_g.BLOCK_SIZE size = max(1, self._calculate_size(bytes_per_tick)) size_str = " (" + human_readable(self._calculate_size(1)) + ")" done = 0 if self.do_cut: self.original_copy_buffer.clear() if len(self.copy_buffer) == 1: self.description = "moving: " + self.one_file.path + size_str else: self.description = "moving files from: " + self.one_file.dirname + size_str for fobj in self.copy_buffer: for path in self.fm.tags.tags: if path == fobj.path or str(path).startswith(fobj.path): tag = self.fm.tags.tags[path] self.fm.tags.remove(path) self.fm.tags.tags[ path.replace(fobj.path, path.join(self.original_path, fobj.basename)) ] = tag self.fm.tags.dump() n = 0 for n in shutil_g.move(src=fobj.path, dst=self.original_path, overwrite=self.overwrite): self.percent = ((done + n) / size) * 100. yield done += n else: if len(self.copy_buffer) == 1: self.description = "copying: " + self.one_file.path + size_str else: self.description = "copying files from: " + self.one_file.dirname + size_str for fobj in self.copy_buffer: if os.path.isdir(fobj.path) and not os.path.islink(fobj.path): n = 0 for n in shutil_g.copytree( src=fobj.path, dst=os.path.join(self.original_path, fobj.basename), symlinks=True, overwrite=self.overwrite, ): self.percent = ((done + n) / size) * 100. yield done += n else: n = 0 for n in shutil_g.copy2(fobj.path, self.original_path, symlinks=True, overwrite=self.overwrite): self.percent = ((done + n) / size) * 100. yield done += n cwd = self.fm.get_directory(self.original_path) cwd.load_content()
def generate(self): from ranger.ext import shutil_generatorized as shutil_g if self.copy_buffer: # TODO: Don't calculate size when renaming (needs detection) bytes_per_tick = shutil_g.BLOCK_SIZE size = max(1, self._calculate_size(bytes_per_tick)) size_str = " (" + human_readable(self._calculate_size(1)) + ")" done = 0 if self.do_cut: self.original_copy_buffer.clear() if len(self.copy_buffer) == 1: self.description = "moving: " + self.one_file.path + size_str else: self.description = "moving files from: " + self.one_file.dirname + size_str for f in self.copy_buffer: for tf in self.fm.tags.tags: if tf == f.path or str(tf).startswith(f.path): tag = self.fm.tags.tags[tf] self.fm.tags.remove(tf) self.fm.tags.tags[tf.replace(f.path, self.original_path + '/' + f.basename)] = tag self.fm.tags.dump() d = 0 for d in shutil_g.move(src=f.path, dst=self.original_path, overwrite=self.overwrite): self.percent = float(done + d) / size * 100. yield done += d else: if len(self.copy_buffer) == 1: self.description = "copying: " + self.one_file.path + size_str else: self.description = "copying files from: " + self.one_file.dirname + size_str for f in self.copy_buffer: if os.path.isdir(f.path) and not os.path.islink(f.path): d = 0 for d in shutil_g.copytree(src=f.path, dst=os.path.join(self.original_path, f.basename), symlinks=True, overwrite=self.overwrite): self.percent = float(done + d) / size * 100. yield done += d else: d = 0 for d in shutil_g.copy2(f.path, self.original_path, symlinks=True, overwrite=self.overwrite): self.percent = float(done + d) / size * 100. yield done += d cwd = self.fm.get_directory(self.original_path) cwd.load_content()
def infostring(self, fobj, metadata): if fobj.stat is None: return '?' size = human_readable(fobj.size) file_date = datetime.fromtimestamp(fobj.stat.st_mtime) time_diff = datetime.now().date() - file_date.date() if time_diff.days > 364: return "%s %11s" % (size, file_date.strftime("%-d %b %Y")) if time_diff.days > 6: return "%s %11s" % (size, file_date.strftime("%-d %b")) elif time_diff.days >= 1: return "%s %11s" % (size, file_date.strftime("%a")) else: return "%s %11s" % (size, file_date.strftime("%H:%M"))
def load_bit_by_bit(self): """An iterator that loads a part on every next() call Returns a generator which load a part of the directory in each iteration. """ self.loading = True self.percent = 0 self.load_if_outdated() try: if self.runnable: yield mypath = self.path self.mount_path = mount_path(mypath) filelist = os.listdir(mypath) if self._cumulative_size_calculated: # If self.content_loaded is true, this is not the first # time loading. So I can't really be sure if the # size has changed and I'll add a "?". if self.content_loaded: if self.fm.settings.autoupdate_cumulative_size: self.look_up_cumulative_size() else: self.infostring = ' %s' % human_readable( self.size, separator='? ') else: self.infostring = ' %s' % human_readable(self.size) else: self.size = len(filelist) self.infostring = ' %d' % self.size if self.is_link: self.infostring = '->' + self.infostring filenames = [mypath + (mypath == '/' and fname or '/' + fname) for fname in filelist] yield self.load_content_mtime = os.stat(mypath).st_mtime marked_paths = [obj.path for obj in self.marked_items] files = [] disk_usage = 0 if self.settings.vcs_aware: self.has_vcschild = False self.load_vcs(None) for name in filenames: try: file_lstat = os_lstat(name) if file_lstat.st_mode & 0o170000 == 0o120000: file_stat = os_stat(name) else: file_stat = file_lstat stats = (file_stat, file_lstat) is_a_dir = file_stat.st_mode & 0o170000 == 0o040000 except: stats = None is_a_dir = False if is_a_dir: try: item = self.fm.get_directory(name) item.load_if_outdated() except: item = Directory(name, preload=stats, path_is_abs=True) item.load() else: item = File(name, preload=stats, path_is_abs=True) item.load() disk_usage += item.size # Load vcs data if self.settings.vcs_aware: item.load_vcs(self) if item.vcs_enabled: self.has_vcschild = True files.append(item) self.percent = 100 * len(files) // len(filenames) yield self.disk_usage = disk_usage self.vcs_outdated = False self.filenames = filenames self.files_all = files self._clear_marked_items() for item in self.files_all: if item.path in marked_paths: item._mark(True) self.marked_items.append(item) else: item._mark(False) self.sort() if files: if self.pointed_obj is not None: self.sync_index() else: self.move(to=0) else: self.filenames = None self.files_all = None self.files = None self.cycle_list = None self.content_loaded = True self.last_update_time = time() self.correct_pointer() finally: self.loading = False self.fm.signal_emit("finished_loading_dir", directory=self)
def load(self): # pylint: disable=too-many-statements """Loads information about the directory itself. reads useful information about the filesystem-object from the filesystem and caches it for later use """ self.loaded = True if self.settings.freeze_files: return self.display_data = {} self.fm.update_preview(self.path) # Get the stat object, either from preload or from [l]stat self.permissions = None new_stat = None path = self.path self.is_link = False if self.preload: new_stat = self.preload[1] self.is_link = new_stat.st_mode & 0o170000 == 0o120000 if self.is_link: new_stat = self.preload[0] self.preload = None self.exists = bool(new_stat) else: try: new_stat = lstat(path) self.is_link = new_stat.st_mode & 0o170000 == 0o120000 if self.is_link: new_stat = stat(path) self.exists = True except OSError: self.exists = False # Set some attributes self.accessible = bool(new_stat) mode = new_stat.st_mode if new_stat else 0 fmt = mode & 0o170000 if fmt in (0o020000, 0o060000): # stat.S_IFCHR/BLK self.is_device = True self.size = 0 self.infostring = 'dev' elif fmt == 0o010000: # stat.S_IFIFO self.is_fifo = True self.size = 0 self.infostring = 'fifo' elif fmt == 0o140000: # stat.S_IFSOCK self.is_socket = True self.size = 0 self.infostring = 'sock' elif self.is_file: if new_stat: self.size = new_stat.st_size self.infostring = ' ' + human_readable(self.size) else: self.size = 0 self.infostring = '?' if self.is_link and not self.is_directory: self.infostring = '-> ' + readlink( self.path) + ' ' + self.infostring self.stat = new_stat self.last_load_time = time()
def _get_right_part(self, bar): # pylint: disable=too-many-branches,too-many-statements right = bar.right if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' right.add(" ", "space") if self.fm.thisdir.flat: right.add("flat=", base, 'flat') right.add(str(self.fm.thisdir.flat), base, 'flat') right.add(", ", "space") if self.fm.thisdir.narrow_filter: right.add("narrowed") right.add(", ", "space") if self.fm.thisdir.filter: right.add("f=`", base, 'filter') right.add(self.fm.thisdir.filter.pattern, base, 'filter') right.add("', ", "space") if target.marked_items: if len(target.marked_items) == target.size: right.add(human_readable(target.disk_usage, separator='')) else: sumsize = sum(f.size for f in target.marked_items if not f.is_directory or f.cumulative_size_calculated) right.add(human_readable(sumsize, separator='')) right.add("/" + str(len(target.marked_items))) else: right.add(human_readable(target.disk_usage, separator='') + " sum") if self.settings.display_free_space_in_status_bar: try: free = get_free_space(target.path) except OSError: pass else: right.add(", ", "space") right.add(human_readable(free, separator='') + " free") right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked') elif target.files: right.add(str(target.pointer + 1) + '/' + str(len(target.files)) + ' ', base) if max_pos <= 0: right.add('All', base, 'all') elif pos == 0: right.add('Top', base, 'top') elif pos >= max_pos: right.add('Bot', base, 'bot') else: right.add('{0:0.0%}'.format((pos / max_pos)), base, 'percentage') else: right.add('0/0 All', base, 'all') if self.settings.freeze_files: # Indicate that files are frozen and will not be loaded right.add(" ", "space") right.add('FROZEN', base, 'frozen')
def infostring(self, file, metadata): ctime=strftime(self.timeformat, localtime(file.stat.st_ctime)) size = human_readable(file.size, separator='') return "%s %s %s %s %s" % (file.get_permission_string(), file.user, file.group, size, ctime)
def _get_right_part(self, bar): # pylint: disable=too-many-branches,too-many-statements right = bar.right if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' right.add(" ", "space") if self.fm.thisdir.flat: right.add("flat=", base, 'flat') right.add(str(self.fm.thisdir.flat), base, 'flat') right.add(", ", "space") if self.fm.thisdir.narrow_filter: right.add("narrowed") right.add(", ", "space") if self.fm.thisdir.filter: right.add("f=`", base, 'filter') right.add(self.fm.thisdir.filter.pattern, base, 'filter') right.add("', ", "space") if target.marked_items: if len(target.marked_items) == target.size: right.add(human_readable(target.disk_usage, separator='')) else: sumsize = sum( f.size for f in target.marked_items if not f.is_directory or f.cumulative_size_calculated) right.add(human_readable(sumsize, separator='')) right.add("/" + str(len(target.marked_items))) else: right.add(human_readable(target.disk_usage, separator='') + " sum") if self.settings.display_free_space_in_status_bar: try: free = get_free_space(target.mount_path) except OSError: pass else: right.add(", ", "space") right.add(human_readable(free, separator='') + " free") right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked') elif target.files: right.add( str(target.pointer + 1) + '/' + str(len(target.files)) + ' ', base) if max_pos <= 0: right.add('All', base, 'all') elif pos == 0: right.add('Top', base, 'top') elif pos >= max_pos: right.add('Bot', base, 'bot') else: right.add('{0:0.0%}'.format((pos / max_pos)), base, 'percentage') else: right.add('0/0 All', base, 'all') if self.settings.freeze_files: # Indicate that files are frozen and will not be loaded right.add(" ", "space") right.add('FROZEN', base, 'frozen')
def infostring(self, fobj, metadata): if fobj.stat is None: return '?' return "%s %s" % (human_readable( fobj.size), datetime.fromtimestamp( fobj.stat.st_mtime).strftime("%Y-%m-%d %H:%M"))
def load(self): """ reads useful information about the filesystem-object from the filesystem and caches it for later use """ self.loaded = True # Get the stat object, either from preload or from [l]stat new_stat = None path = self.path is_link = False if self.preload: new_stat = self.preload[1] is_link = new_stat.st_mode & 0o170000 == 0o120000 if is_link: new_stat = self.preload[0] self.preload = None self.exists = True if new_stat else False else: try: new_stat = lstat(path) is_link = new_stat.st_mode & 0o170000 == 0o120000 if is_link: new_stat = stat(path) self.exists = True except: self.exists = False # Set some attributes self.accessible = True if new_stat else False mode = new_stat.st_mode if new_stat else 0 format = mode & 0o170000 if format == 0o020000 or format == 0o060000: # stat.S_IFCHR/BLK self.is_device = True self.size = 0 self.infostring = 'dev' elif format == 0o010000: # stat.S_IFIFO self.is_fifo = True self.size = 0 self.infostring = 'fifo' elif format == 0o140000: # stat.S_IFSOCK self.is_socket = True self.size = 0 self.infostring = 'sock' elif self.is_file: if new_stat: self.size = new_stat.st_size self.infostring = ' ' + human_readable(self.size) else: self.size = 0 self.infostring = '?' elif self.is_directory: try: self.size = len(listdir(path)) # bite me except OSError: self.size = 0 self.infostring = '?' self.accessible = False else: self.infostring = ' %d' % self.size self.accessible = True self.runnable = True if is_link: self.infostring = '->' + self.infostring self.is_link = True self.stat = new_stat
def look_up_cumulative_size(self): self.cumulative_size_calculated = True self.size = self._get_cumulative_size() self.infostring = ('-> ' if self.is_link else ' ') + human_readable( self.size)
def infostring(self, file, metadata): return "%s %s" % (human_readable(file.size), datetime.fromtimestamp(file.stat.st_mtime).strftime("%Y-%m-%d %H:%M"))
def look_up_cumulative_size(self): self.cumulative_size_calculated = True self.size = self._get_cumulative_size() self.infostring = ('-> ' if self.is_link else ' ') + human_readable(self.size)
def infostring(self, fobj, metadata): if fobj.stat is None: return '?' return "%s %s" % (human_readable(fobj.size), datetime.fromtimestamp(fobj.stat.st_mtime).strftime("%Y-%m-%d %H:%M"))
def infostring(self, fobj, metadata): if fobj.stat is None: return '?' humanSize = human_readable(fobj.size) return "%s" % humanSize
def _get_right_part(self, bar): right = bar.right # This chunk is to get file size working on the right side. if self.column is not None and self.column.target is not None\ and self.column.target.is_directory: target = self.column.target.pointed_obj else: directory = self.fm.thistab.at_level(0) if directory: target = directory.pointed_obj else: return try: stat = target.stat except: return if stat is None: return if self.fm.mode != 'normal': perms = '--%s--' % self.fm.mode.upper() else: perms = target.get_permission_string() how = getuid() == stat.st_uid and 'good' or 'bad' if target.is_link: how = target.exists and 'good' or 'bad' try: dest = readlink(target.path) except: dest = '?' right.add(' -> ' + dest, 'link', how) else: if self.settings.display_size_in_status_bar and target.infostring: right.add(" " + target.infostring.replace(" ", "")) right.add(" »", "space") if self.column is None: return target = self.column.target if target is None \ or not target.accessible \ or (target.is_directory and target.files is None): return pos = target.scroll_begin max_pos = len(target) - self.column.hei base = 'scroll' if self.fm.thisdir.filter: right.add(" f=`", base, 'filter') right.add(self.fm.thisdir.filter.pattern, base, 'filter') right.add("', ", "space") if target.marked_items: if len(target.marked_items) == len(target.files): #right.add(human_readable(target.disk_usage, separator='')) right.add(" " + human_readable(target.disk_usage, separator='')) else: sumsize = sum(f.size for f in target.marked_items if not f.is_directory or f._cumulative_size_calculated) #right.add(human_readable(sumsize, separator='')) right.add(" " + human_readable(sumsize, separator='')) right.add("/" + str(len(target.marked_items))) else: #right.add(human_readable(target.disk_usage, separator='') + " sum") right.add(" " + human_readable(target.disk_usage, separator='')) try: free = get_free_space(target.mount_path) except OSError: pass else: #right.add(", ", "space") right.add(" » ", "space") #right.add(human_readable(free, separator='') + " free") right.add(human_readable(free, separator='')) right.add(" ", "space") if target.marked_items: # Indicate that there are marked files. Useful if you scroll # away and don't see them anymore. right.add('Mrk', base, 'marked')
def load_bit_by_bit(self): """An iterator that loads a part on every next() call Returns a generator which load a part of the directory in each iteration. """ self.loading = True self.percent = 0 self.load_if_outdated() basename_is_rel_to = self.path if self.flat else None try: # pylint: disable=too-many-nested-blocks if self.runnable: yield mypath = self.path self.mount_path = mount_path(mypath) if self.flat: filelist = [] for dirpath, dirnames, filenames in walklevel(mypath, self.flat): dirlist = [ os.path.join("/", dirpath, d) for d in dirnames if self.flat == -1 or (dirpath.count(os.path.sep) - mypath.count(os.path.sep)) <= self.flat ] filelist += dirlist filelist += [os.path.join("/", dirpath, f) for f in filenames] filenames = filelist self.load_content_mtime = mtimelevel(mypath, self.flat) else: filelist = os.listdir(mypath) filenames = [mypath + (mypath == '/' and fname or '/' + fname) for fname in filelist] self.load_content_mtime = os.stat(mypath).st_mtime if self.cumulative_size_calculated: # If self.content_loaded is true, this is not the first # time loading. So I can't really be sure if the # size has changed and I'll add a "?". if self.content_loaded: if self.fm.settings.autoupdate_cumulative_size: self.look_up_cumulative_size() else: self.infostring = ' %s' % human_readable( self.size, separator='? ') else: self.infostring = ' %s' % human_readable(self.size) else: self.size = len(filelist) self.infostring = ' %d' % self.size if self.is_link: self.infostring = '->' + self.infostring yield marked_paths = [obj.path for obj in self.marked_items] files = [] disk_usage = 0 has_vcschild = False for name in filenames: try: file_lstat = os_lstat(name) if file_lstat.st_mode & 0o170000 == 0o120000: file_stat = os_stat(name) else: file_stat = file_lstat except OSError: file_lstat = None file_stat = None if file_lstat and file_stat: stats = (file_stat, file_lstat) is_a_dir = file_stat.st_mode & 0o170000 == 0o040000 else: stats = None is_a_dir = False if is_a_dir: item = self.fm.get_directory(name, preload=stats, path_is_abs=True, basename_is_rel_to=basename_is_rel_to) item.load_if_outdated() if self.flat: item.relative_path = os.path.relpath(item.path, self.path) else: item.relative_path = item.basename item.relative_path_lower = item.relative_path.lower() if item.vcs and item.vcs.track: if item.vcs.is_root_pointer: has_vcschild = True else: item.vcsstatus = \ item.vcs.rootvcs.status_subpath( # pylint: disable=no-member os.path.join(self.realpath, item.basename), is_directory=True, ) else: item = File(name, preload=stats, path_is_abs=True, basename_is_rel_to=basename_is_rel_to) item.load() disk_usage += item.size if self.vcs and self.vcs.track: item.vcsstatus = \ self.vcs.rootvcs.status_subpath( # pylint: disable=no-member os.path.join(self.realpath, item.basename)) files.append(item) self.percent = 100 * len(files) // len(filenames) yield self.has_vcschild = has_vcschild self.disk_usage = disk_usage self.filenames = filenames self.files_all = files self._clear_marked_items() for item in self.files_all: if item.path in marked_paths: item.mark_set(True) self.marked_items.append(item) else: item.mark_set(False) self.sort() if files: if self.pointed_obj is not None: self.sync_index() else: self.move(to=0) else: self.filenames = None self.files_all = None self.files = None self.cycle_list = None self.content_loaded = True self.last_update_time = time() self.correct_pointer() finally: self.loading = False self.fm.signal_emit("finished_loading_dir", directory=self) if self.vcs: self.fm.ui.vcsthread.process(self)
def infostring(self, fobj, metadata): if fobj.stat is None: return '?' size = human_readable(fobj.size) return "%s %11s" % (size, human_readable_time(fobj.stat.st_mtime))
def load_bit_by_bit(self): """An iterator that loads a part on every next() call Returns a generator which load a part of the directory in each iteration. """ self.loading = True self.percent = 0 self.load_if_outdated() basename_is_rel_to = self.path if self.flat else None try: if self.runnable: yield mypath = self.path self.mount_path = mount_path(mypath) if self.flat: filelist = [] for dirpath, dirnames, filenames in walklevel( mypath, self.flat): dirlist = [ os.path.join("/", dirpath, d) for d in dirnames if self.flat == -1 or dirpath.count(os.path.sep) - mypath.count(os.path.sep) <= self.flat ] filelist += dirlist filelist += [ os.path.join("/", dirpath, f) for f in filenames ] filenames = filelist self.load_content_mtime = mtimelevel(mypath, self.flat) else: filelist = os.listdir(mypath) filenames = [ mypath + (mypath == '/' and fname or '/' + fname) for fname in filelist ] self.load_content_mtime = os.stat(mypath).st_mtime if self._cumulative_size_calculated: # If self.content_loaded is true, this is not the first # time loading. So I can't really be sure if the # size has changed and I'll add a "?". if self.content_loaded: if self.fm.settings.autoupdate_cumulative_size: self.look_up_cumulative_size() else: self.infostring = ' %s' % human_readable( self.size, separator='? ') else: self.infostring = ' %s' % human_readable(self.size) else: self.size = len(filelist) self.infostring = ' %d' % self.size if self.is_link: self.infostring = '->' + self.infostring yield marked_paths = [obj.path for obj in self.marked_items] files = [] disk_usage = 0 if self.settings.vcs_aware: self.has_vcschild = False self.load_vcs(None) for name in filenames: try: file_lstat = os_lstat(name) if file_lstat.st_mode & 0o170000 == 0o120000: file_stat = os_stat(name) else: file_stat = file_lstat stats = (file_stat, file_lstat) is_a_dir = file_stat.st_mode & 0o170000 == 0o040000 except: stats = None is_a_dir = False if is_a_dir: if self.flat: item = Directory( name, preload=stats, path_is_abs=True, basename_is_rel_to=basename_is_rel_to) item.load() else: try: item = self.fm.get_directory(name) item.load_if_outdated() except: item = Directory(name, preload=stats, path_is_abs=True) item.load() else: item = File(name, preload=stats, path_is_abs=True, basename_is_rel_to=basename_is_rel_to) item.load() disk_usage += item.size # Load vcs data if self.settings.vcs_aware: item.load_vcs(self) if item.vcs_enabled: self.has_vcschild = True files.append(item) self.percent = 100 * len(files) // len(filenames) yield self.disk_usage = disk_usage self.vcs_outdated = False self.filenames = filenames self.files_all = files self._clear_marked_items() for item in self.files_all: if item.path in marked_paths: item._mark(True) self.marked_items.append(item) else: item._mark(False) self.sort() if files: if self.pointed_obj is not None: self.sync_index() else: self.move(to=0) else: self.filenames = None self.files_all = None self.files = None self.cycle_list = None self.content_loaded = True self.last_update_time = time() self.correct_pointer() finally: self.loading = False self.fm.signal_emit("finished_loading_dir", directory=self)
def load_bit_by_bit(self): """ Returns a generator which load a part of the directory in each iteration. """ self.loading = True self.percent = 0 self.load_if_outdated() try: if self.runnable: yield mypath = self.path self.mount_path = mount_path(mypath) if not self.settings.show_hidden and self.settings.hidden_filter: # COMPAT # hidden_filter used to be a regex, not a string. If an # old config is used, we don't need to re.compile it. if hasattr(self.settings.hidden_filter, 'search'): hidden_filter = self.settings.hidden_filter else: hidden_filter = re.compile(self.settings.hidden_filter) else: hidden_filter = None filelist = os.listdir(mypath) if self._cumulative_size_calculated: # If self.content_loaded is true, this is not the first # time loading. So I can't really be sure if the # size has changed and I'll add a "?". if self.content_loaded: if self.fm.settings.autoupdate_cumulative_size: self.look_up_cumulative_size() else: self.infostring = ' %s' % human_readable( self.size, separator='? ') else: self.infostring = ' %s' % human_readable(self.size) else: self.size = len(filelist) self.infostring = ' %d' % self.size if self.is_link: self.infostring = '->' + self.infostring filenames = [mypath + (mypath == '/' and fname or '/' + fname)\ for fname in filelist if accept_file( fname, mypath, hidden_filter, self.filter)] yield self.load_content_mtime = os.stat(mypath).st_mtime marked_paths = [obj.path for obj in self.marked_items] files = [] disk_usage = 0 for name in filenames: try: file_lstat = os_lstat(name) if file_lstat.st_mode & 0o170000 == 0o120000: file_stat = os_stat(name) else: file_stat = file_lstat stats = (file_stat, file_lstat) is_a_dir = file_stat.st_mode & 0o170000 == 0o040000 except: stats = None is_a_dir = False if is_a_dir: try: item = self.fm.get_directory(name) item.load_if_outdated() except: item = Directory(name, preload=stats, path_is_abs=True) item.load() else: item = File(name, preload=stats, path_is_abs=True) item.load() disk_usage += item.size files.append(item) self.percent = 100 * len(files) // len(filenames) yield self.disk_usage = disk_usage self.filenames = filenames self.files = files self._clear_marked_items() for item in self.files: if item.path in marked_paths: item._mark(True) self.marked_items.append(item) else: item._mark(False) self.sort() if files: if self.pointed_obj is not None: self.sync_index() else: self.move(to=0) else: self.filenames = None self.files = None self.cycle_list = None self.content_loaded = True self.last_update_time = time() self.correct_pointer() finally: self.loading = False self.fm.signal_emit("finished_loading_dir", directory=self)
def load_bit_by_bit(self): """An iterator that loads a part on every next() call Returns a generator which load a part of the directory in each iteration. """ self.loading = True self.percent = 0 self.load_if_outdated() basename_is_rel_to = self.path if self.flat else None try: # pylint: disable=too-many-nested-blocks if self.runnable: yield mypath = self.path self.mount_path = mount_path(mypath) def ignore_files(): directory = expanduser("~") files = [] for filename in os.listdir(directory): if filename.startswith( "ranger_") and filename.endswith(".txt"): with open(os.path.join(directory, filename), 'r') as f: files += f.read().strip().split("\n") return list(set(files)) if self.flat: filelist = [] for dirpath, dirnames, filenames in walklevel( mypath, self.flat): dirlist = [ os.path.join("/", dirpath, d) for d in dirnames if self.flat == -1 or (dirpath.count(os.path.sep) - mypath.count(os.path.sep)) <= self.flat ] filelist += dirlist filelist += [ os.path.join("/", dirpath, f) for f in filenames ] filenames = filelist filenames = [ f for f in filenames if not f in ignore_files() ] self.load_content_mtime = mtimelevel(mypath, self.flat) else: filelist = os.listdir(mypath) filenames = [ mypath + (mypath == '/' and fname or '/' + fname) for fname in filelist ] filenames = [ f for f in filenames if not f in ignore_files() ] self.load_content_mtime = os.stat(mypath).st_mtime if self.cumulative_size_calculated: # If self.content_loaded is true, this is not the first # time loading. So I can't really be sure if the # size has changed and I'll add a "?". if self.content_loaded: if self.fm.settings.autoupdate_cumulative_size: self.look_up_cumulative_size() else: self.infostring = ' %s' % human_readable( self.size, separator='? ') else: self.infostring = ' %s' % human_readable(self.size) else: self.size = len(filelist) self.infostring = ' %d' % self.size if self.is_link: self.infostring = '->' + self.infostring yield marked_paths = [obj.path for obj in self.marked_items] files = [] disk_usage = 0 has_vcschild = False for name in filenames: try: file_lstat = os_lstat(name) if file_lstat.st_mode & 0o170000 == 0o120000: file_stat = os_stat(name) else: file_stat = file_lstat except OSError: file_lstat = None file_stat = None if file_lstat and file_stat: stats = (file_stat, file_lstat) is_a_dir = file_stat.st_mode & 0o170000 == 0o040000 else: stats = None is_a_dir = False if is_a_dir: item = self.fm.get_directory( name, preload=stats, path_is_abs=True, basename_is_rel_to=basename_is_rel_to) item.load_if_outdated() if self.flat: item.relative_path = os.path.relpath( item.path, self.path) else: item.relative_path = item.basename item.relative_path_lower = item.relative_path.lower() if item.vcs and item.vcs.track: if item.vcs.is_root_pointer: has_vcschild = True else: item.vcsstatus = \ item.vcs.rootvcs.status_subpath( # pylint: disable=no-member os.path.join(self.realpath, item.basename), is_directory=True, ) else: item = File(name, preload=stats, path_is_abs=True, basename_is_rel_to=basename_is_rel_to) item.load() disk_usage += item.size if self.vcs and self.vcs.track: item.vcsstatus = \ self.vcs.rootvcs.status_subpath( # pylint: disable=no-member os.path.join(self.realpath, item.basename)) files.append(item) self.percent = 100 * len(files) // len(filenames) yield self.has_vcschild = has_vcschild self.disk_usage = disk_usage self.filenames = filenames self.files_all = files self._clear_marked_items() for item in self.files_all: if item.path in marked_paths: item.mark_set(True) self.marked_items.append(item) else: item.mark_set(False) self.sort() if files: if self.pointed_obj is not None: self.sync_index() else: self.move(to=0) else: self.filenames = None self.files_all = None self.files = None self.cycle_list = None self.content_loaded = True self.last_update_time = time() self.correct_pointer() finally: self.loading = False self.fm.signal_emit("finished_loading_dir", directory=self) if self.vcs: self.fm.ui.vcsthread.process(self)
def load(self): """Loads information about the directory itself. reads useful information about the filesystem-object from the filesystem and caches it for later use """ self.display_data = {} self.fm.update_preview(self.path) self.loaded = True # Get the stat object, either from preload or from [l]stat self.permissions = None new_stat = None path = self.path is_link = False if self.preload: new_stat = self.preload[1] self.is_link = new_stat.st_mode & 0o170000 == 0o120000 if self.is_link: new_stat = self.preload[0] self.preload = None self.exists = True if new_stat else False else: try: new_stat = lstat(path) self.is_link = new_stat.st_mode & 0o170000 == 0o120000 if self.is_link: new_stat = stat(path) self.exists = True except: self.exists = False # Set some attributes self.accessible = True if new_stat else False mode = new_stat.st_mode if new_stat else 0 format = mode & 0o170000 if format == 0o020000 or format == 0o060000: # stat.S_IFCHR/BLK self.is_device = True self.size = 0 self.infostring = 'dev' elif format == 0o010000: # stat.S_IFIFO self.is_fifo = True self.size = 0 self.infostring = 'fifo' elif format == 0o140000: # stat.S_IFSOCK self.is_socket = True self.size = 0 self.infostring = 'sock' elif self.is_file: if new_stat: self.size = new_stat.st_size self.infostring = ' ' + human_readable(self.size) else: self.size = 0 self.infostring = '?' if self.is_link and not self.is_directory: self.infostring = '->' + self.infostring self.stat = new_stat