id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
700 | displayable.py | ranger_ranger/ranger/gui/displayable.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import curses
from ranger.core.shared import FileManagerAware
from ranger.gui.curses_shortcuts import CursesShortcuts
try:
from bidi.algorithm import get_display # pylint: disable=import-error
HAVE_BIDI = True
except ImportError:
HAVE_BIDI = False
class Displayable( # pylint: disable=too-many-instance-attributes
FileManagerAware, CursesShortcuts):
"""Displayables are objects which are displayed on the screen.
This is just the abstract class, defining basic operations
such as resizing, printing, changing colors.
Subclasses of displayable can extend these methods:
draw() -- draw the object. Is only called if visible.
poke() -- is called just before draw(), even if not visible.
finalize() -- called after all objects finished drawing.
click(event) -- called with a MouseEvent. This is called on all
visible objects under the mouse, until one returns True.
press(key) -- called after a key press on focused objects.
destroy() -- called before destroying the displayable object
Additionally, there are these methods:
__contains__(item) -- is the item (y, x) inside the widget?
These attributes are set:
Modifiable:
focused -- Focused objects receive press() calls.
visible -- Visible objects receive draw() and finalize() calls
need_redraw -- Should the widget be redrawn? This variable may
be set at various places in the script and should eventually be
handled (and unset) in the draw() method.
Read-Only: (i.e. recommended not to change manually)
win -- the own curses window object
parent -- the parent (DisplayableContainer) object or None
x, y, wid, hei -- absolute coordinates and boundaries
settings, fm -- inherited shared variables
"""
def __init__(self, win, # pylint: disable=super-init-not-called
env=None, fm=None, settings=None):
from ranger.gui.ui import UI
if env is not None:
self.env = env
if fm is not None:
self.fm = fm
if settings is not None:
self.settings = settings
self.need_redraw = True
self.focused = False
self.visible = True
self.x = 0
self.y = 0
self.wid = 0
self.hei = 0
self.paryx = (0, 0)
self.parent = None
self._old_visible = self.visible
if win is not None:
if isinstance(self, UI):
self.win = win
else:
self.win = win.derwin(1, 1, 0, 0)
def __nonzero__(self):
"""Always True"""
return True
__bool__ = __nonzero__
def __contains__(self, item):
"""Checks if item is inside the boundaries.
item can be an iterable like [y, x] or an object with x and y methods.
"""
try:
y, x = item.y, item.x
except AttributeError:
try:
y, x = item
except (ValueError, TypeError):
return False
return self.contains_point(y, x)
def draw(self):
"""Draw the object.
Called on every main iteration if visible. Containers should call
draw() on their contained objects here. Override this!
"""
def destroy(self):
"""Called when the object is destroyed."""
self.win = None
def contains_point(self, y, x):
"""Test whether the point lies inside this object.
x and y should be absolute coordinates.
"""
return (self.x <= x < self.x + self.wid) and \
(self.y <= y < self.y + self.hei)
def click(self, event):
"""Called when a mouse key is pressed and self.focused is True.
Override this!
"""
def press(self, key):
"""Called when a key is pressed and self.focused is True.
Override this!
"""
def poke(self):
"""Called before drawing, even if invisible"""
if self._old_visible != self.visible:
self._old_visible = self.visible
self.need_redraw = True
if not self.visible:
self.win.erase()
def finalize(self):
"""Called after every displayable is done drawing.
Override this!
"""
def resize(self, y, x, hei=None, wid=None):
"""Resize the widget"""
do_move = True
try:
maxy, maxx = self.fm.ui.termsize
except TypeError:
pass
else:
if hei is None:
hei = maxy - y
if wid is None:
wid = maxx - x
if x < 0 or y < 0:
self.fm.notify("Warning: Subwindow origin below zero for <%s> "
"(x = %d, y = %d)" % (self, x, y), bad=True)
if x + wid > maxx or y + hei > maxy:
self.fm.notify(
"Warning: Subwindow size out of bounds for <%s> "
"(x = %d, y = %d, hei = %d, wid = %d)" % (self, x, y, hei, wid),
bad=True,
)
window_is_cleared = False
if hei != self.hei or wid != self.wid:
# log("resizing " + str(self))
self.win.erase()
self.need_redraw = True
window_is_cleared = True
try:
self.win.resize(hei, wid)
except curses.error:
# Not enough space for resizing...
try:
self.win.mvderwin(0, 0)
do_move = True
self.win.resize(hei, wid)
except curses.error:
pass
# raise ValueError("Resizing Failed!")
self.hei, self.wid = self.win.getmaxyx()
if do_move or y != self.paryx[0] or x != self.paryx[1]:
if not window_is_cleared:
self.win.erase()
self.need_redraw = True
# log("moving " + str(self))
try:
self.win.mvderwin(y, x)
except curses.error:
try:
self.win.resize(hei, wid)
self.win.mvderwin(y, x)
except curses.error:
pass
self.paryx = self.win.getparyx()
self.y, self.x = self.paryx
if self.parent:
self.y += self.parent.y
self.x += self.parent.x
def __str__(self):
return self.__class__.__name__
def bidi_transpose(self, text):
if self.settings.bidi_support and HAVE_BIDI:
return get_display(text)
return text
class DisplayableContainer(Displayable):
"""DisplayableContainers are Displayables which contain other Displayables.
This is also an abstract class. The methods draw, poke, finalize,
click, press and destroy are extended here and will recursively
call the function on all contained objects.
New methods:
add_child(object) -- add the object to the container.
replace_child(old_obj, new_obj) -- replaces old object with new object.
remove_child(object) -- remove the object from the container.
New attributes:
container -- a list with all contained objects (rw)
"""
def __init__(self, win, env=None, fm=None, settings=None):
if env is not None:
self.env = env
if fm is not None:
self.fm = fm
if settings is not None:
self.settings = settings
self.container = []
Displayable.__init__(self, win)
# ------------------------------------ extended or overridden methods
def poke(self):
"""Recursively called on objects in container"""
Displayable.poke(self)
for displayable in self.container:
displayable.poke()
def draw(self):
"""Recursively called on visible objects in container"""
for displayable in self.container:
if self.need_redraw:
displayable.need_redraw = True
if displayable.visible:
displayable.draw()
self.need_redraw = False
def finalize(self):
"""Recursively called on visible objects in container"""
for displayable in self.container:
if displayable.visible:
displayable.finalize()
def press(self, key):
"""Recursively called on objects in container"""
focused_obj = self.get_focused_obj()
if focused_obj:
focused_obj.press(key)
return True
return False
def click(self, event):
"""Recursively called on objects in container"""
focused_obj = self.get_focused_obj()
if focused_obj and focused_obj.click(event):
return True
for displayable in self.container:
if displayable.visible and event in displayable:
if displayable.click(event):
return True
return False
def destroy(self):
"""Recursively called on objects in container"""
for displayable in self.container:
displayable.destroy()
# ----------------------------------------------- new methods
def add_child(self, obj):
"""Add the objects to the container."""
if obj.parent:
obj.parent.remove_child(obj)
self.container.append(obj)
obj.parent = self
def replace_child(self, old_obj, new_obj):
"""Replace the old object with the new instance in the container."""
self.container[self.container.index(old_obj)] = new_obj
new_obj.parent = self
def remove_child(self, obj):
"""Remove the object from the container."""
try:
self.container.remove(obj)
except ValueError:
pass
else:
obj.parent = None
def get_focused_obj(self):
# Finds a focused displayable object in the container.
for displayable in self.container:
if displayable.focused:
return displayable
try:
obj = displayable.get_focused_obj()
except AttributeError:
pass
else:
if obj is not None:
return obj
return None
| 10,580 | Python | .py | 268 | 28.970149 | 84 | 0.571875 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
701 | colorscheme.py | ranger_ranger/ranger/gui/colorscheme.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Colorschemes define colors for specific contexts.
Generally, this works by passing a set of keywords (strings) to
the colorscheme.get() method to receive the tuple (fg, bg, attr).
fg, bg are the foreground and background colors and attr is the attribute.
The values are specified in ranger.gui.color.
A colorscheme must...
1. be inside either of these directories:
~/.config/ranger/colorschemes/
path/to/ranger/colorschemes/
2. be a subclass of ranger.gui.colorscheme.ColorScheme
3. implement a use(self, context) method which returns (fg, bg, attr).
context is a struct which contains all entries of CONTEXT_KEYS,
associated with either True or False.
Define which colorscheme in your settings (e.g. ~/.config/ranger/rc.conf):
set colorscheme yourschemename
"""
from __future__ import (absolute_import, division, print_function)
import os.path
from abc import abstractmethod
from curses import color_pair
from io import open
import ranger
from ranger.gui.color import get_color
from ranger.gui.context import Context
from ranger.core.main import allow_access_to_confdir
from ranger.ext.cached_function import cached_function
from ranger.ext.iter_tools import flatten
class ColorSchemeError(Exception):
pass
class ColorScheme(object):
"""This is the class that colorschemes must inherit from.
it defines the get() method, which returns the color tuple
which fits to the given keys.
"""
@cached_function
def get(self, *keys):
"""Returns the (fg, bg, attr) for the given keys.
Using this function rather than use() will cache all
colors for faster access.
"""
context = Context(keys)
color = self.use(context)
if len(color) != 3 or not all(isinstance(value, int) for value in color):
raise ValueError("Bad Value from colorscheme. Need "
"a tuple of (foreground_color, background_color, attribute).")
return color
@cached_function
def get_attr(self, *keys):
"""Returns the curses attribute for the specified keys
Ready to use for curses.setattr()
"""
fg, bg, attr = self.get(*flatten(keys))
return attr | color_pair(get_color(fg, bg))
@abstractmethod
def use(self, context):
"""Use the colorscheme to determine the (fg, bg, attr) tuple.
Override this method in your own colorscheme.
"""
return (-1, -1, 0)
def _colorscheme_name_to_class(signal): # pylint: disable=too-many-branches
# Find the colorscheme. First look in ~/.config/ranger/colorschemes,
# then at RANGERDIR/colorschemes. If the file contains a class
# named Scheme, it is used. Otherwise, an arbitrary other class
# is picked.
if isinstance(signal.value, ColorScheme):
return
if not signal.value:
signal.value = 'default'
scheme_name = signal.value
usecustom = not ranger.args.clean
def exists(colorscheme):
return os.path.exists(colorscheme + '.py') or os.path.exists(colorscheme + '.pyc')
def is_scheme(cls):
try:
return issubclass(cls, ColorScheme)
except TypeError:
return False
# create ~/.config/ranger/colorschemes/__init__.py if it doesn't exist
if usecustom:
if os.path.exists(signal.fm.confpath('colorschemes')):
initpy = signal.fm.confpath('colorschemes', '__init__.py')
if not os.path.exists(initpy):
with open(initpy, "a", encoding="utf-8"):
# Just create the file
pass
if usecustom and \
exists(signal.fm.confpath('colorschemes', scheme_name)):
scheme_supermodule = 'colorschemes'
elif exists(signal.fm.relpath('colorschemes', scheme_name)):
scheme_supermodule = 'ranger.colorschemes'
usecustom = False
else:
scheme_supermodule = None # found no matching file.
if scheme_supermodule is None:
if signal.previous and isinstance(signal.previous, ColorScheme):
signal.value = signal.previous
else:
signal.value = ColorScheme()
raise ColorSchemeError("Cannot locate colorscheme `%s'" % scheme_name)
else:
if usecustom:
allow_access_to_confdir(ranger.args.confdir, True)
scheme_module = getattr(
__import__(scheme_supermodule, globals(), locals(), [scheme_name], 0), scheme_name)
if usecustom:
allow_access_to_confdir(ranger.args.confdir, False)
if hasattr(scheme_module, 'Scheme') and is_scheme(scheme_module.Scheme):
signal.value = scheme_module.Scheme()
else:
for var in scheme_module.__dict__.values():
if var != ColorScheme and is_scheme(var):
signal.value = var()
break
else:
raise ColorSchemeError("The module contains no valid colorscheme!")
def get_all_colorschemes(fm):
colorschemes = set()
# Load colorscheme names from main ranger/colorschemes dir
for item in os.listdir(os.path.join(ranger.RANGERDIR, 'colorschemes')):
if not item.startswith('__'):
colorschemes.add(item.rsplit('.', 1)[0])
# Load colorscheme names from ~/.config/ranger/colorschemes if dir exists
confpath = fm.confpath('colorschemes')
if os.path.isdir(confpath):
for item in os.listdir(confpath):
if not item.startswith('__'):
colorschemes.add(item.rsplit('.', 1)[0])
return list(sorted(colorschemes))
| 5,717 | Python | .py | 130 | 36.569231 | 95 | 0.669307 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
702 | color.py | ranger_ranger/ranger/gui/color.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Contains abbreviations to curses color/attribute constants.
Multiple attributes can be combined with the | (or) operator, toggled
with ^ (xor) and checked for with & (and). Examples:
attr = bold | underline
attr |= reverse
bool(attr & reverse) # => True
attr ^= reverse
bool(attr & reverse) # => False
"""
from __future__ import (absolute_import, division, print_function)
import curses
DEFAULT_FOREGROUND = curses.COLOR_WHITE
DEFAULT_BACKGROUND = curses.COLOR_BLACK
# Color pair 0 is wired to white on black and cannot be changed
COLOR_PAIRS = {(DEFAULT_FOREGROUND, DEFAULT_BACKGROUND): 0}
def get_color(fg, bg):
"""Returns the curses color pair for the given fg/bg combination."""
key = (fg, bg)
if key not in COLOR_PAIRS:
size = len(COLOR_PAIRS)
try:
curses.init_pair(size, fg, bg)
except ValueError:
# We're trying to add more pairs than the terminal can store,
# approximating to the closest color pair that's already stored
# would be cool but the easier solution is to just fall back to the
# default fore and background colors, pair 0
COLOR_PAIRS[key] = 0
except curses.error:
# If curses.use_default_colors() failed during the initialization
# of curses, then using -1 as fg or bg will fail as well, which
# we need to handle with fallback-defaults:
if fg == -1: # -1 is the "default" color
fg = DEFAULT_FOREGROUND
if bg == -1: # -1 is the "default" color
bg = DEFAULT_BACKGROUND
try:
curses.init_pair(size, fg, bg)
except curses.error:
# If this fails too, colors are probably not supported
pass
COLOR_PAIRS[key] = size
else:
COLOR_PAIRS[key] = size
return COLOR_PAIRS[key]
# pylint: disable=invalid-name
black = curses.COLOR_BLACK
blue = curses.COLOR_BLUE
cyan = curses.COLOR_CYAN
green = curses.COLOR_GREEN
magenta = curses.COLOR_MAGENTA
red = curses.COLOR_RED
white = curses.COLOR_WHITE
yellow = curses.COLOR_YELLOW
default = -1
normal = curses.A_NORMAL
bold = curses.A_BOLD
blink = curses.A_BLINK
reverse = curses.A_REVERSE
underline = curses.A_UNDERLINE
invisible = curses.A_INVIS
dim = curses.A_DIM
default_colors = (default, default, normal)
# pylint: enable=invalid-name
curses.setupterm()
# Adding BRIGHT to a color achieves what `bold` was used for.
BRIGHT = 8 if curses.tigetnum('colors') >= 16 else 0
| 2,683 | Python | .py | 69 | 33.072464 | 79 | 0.672055 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
703 | curses_shortcuts.py | ranger_ranger/ranger/gui/curses_shortcuts.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import sys
import curses
from ranger.gui.color import get_color
from ranger.core.shared import SettingsAware
REVERSE_ADDCH_ARGS = sys.version[0:5] == '3.4.0'
def _fix_surrogates(args):
return [isinstance(arg, str) and arg.encode('utf-8', 'surrogateescape')
.decode('utf-8', 'replace') or arg for arg in args]
class CursesShortcuts(SettingsAware):
"""This class defines shortcuts to facilitate operations with curses.
color(*keys) -- sets the color associated with the keys from
the current colorscheme.
color_at(y, x, wid, *keys) -- sets the color at the given position
color_reset() -- resets the color to the default
addstr(*args) -- failsafe version of self.win.addstr(*args)
"""
def __init__(self):
self.win = None
def addstr(self, *args):
y, x = self.win.getyx()
try:
self.win.addstr(*args)
except (curses.error, TypeError, ValueError):
# a TypeError changed to ValueError from version 3.5 onwards
# https://bugs.python.org/issue22215
if len(args) > 1:
self.win.move(y, x)
try:
self.win.addstr(*_fix_surrogates(args))
except (curses.error, UnicodeError, ValueError, TypeError):
pass
def addnstr(self, *args):
y, x = self.win.getyx()
try:
self.win.addnstr(*args)
except (curses.error, TypeError, ValueError, TypeError):
if len(args) > 2:
self.win.move(y, x)
try:
self.win.addnstr(*_fix_surrogates(args))
except (curses.error, UnicodeError, ValueError, TypeError):
pass
def addch(self, *args):
if REVERSE_ADDCH_ARGS and len(args) >= 3:
args = [args[1], args[0]] + list(args[2:])
try:
self.win.addch(*args)
except (curses.error, TypeError):
pass
def color(self, *keys):
"""Change the colors from now on."""
attr = self.settings.colorscheme.get_attr(*keys)
try:
self.win.attrset(attr)
except curses.error:
pass
def color_at(self, y, x, wid, *keys):
"""Change the colors at the specified position"""
attr = self.settings.colorscheme.get_attr(*keys)
try:
self.win.chgat(y, x, wid, attr)
except curses.error:
pass
def set_fg_bg_attr(self, fg, bg, attr):
try:
self.win.attrset(curses.color_pair(get_color(fg, bg)) | attr)
except curses.error:
pass
def color_reset(self):
"""Change the colors to the default colors"""
CursesShortcuts.color(self, 'reset')
| 2,974 | Python | .py | 74 | 30.635135 | 75 | 0.593956 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
704 | titlebar.py | ranger_ranger/ranger/gui/widgets/titlebar.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The titlebar is the widget at the top, giving you broad overview.
It displays the current path among other things.
"""
from __future__ import (absolute_import, division, print_function)
from os.path import basename
from ranger.gui.bar import Bar
from . import Widget
class TitleBar(Widget):
old_thisfile = None
old_keybuffer = None
old_wid = None
result = None
right_sumsize = 0
throbber = ' '
need_redraw = False
def __init__(self, *args, **keywords):
Widget.__init__(self, *args, **keywords)
self.fm.signal_bind('tab.change', self.request_redraw, weak=True)
def request_redraw(self):
self.need_redraw = True
def draw(self):
if self.need_redraw or \
self.fm.thisfile != self.old_thisfile or\
str(self.fm.ui.keybuffer) != str(self.old_keybuffer) or\
self.wid != self.old_wid:
self.need_redraw = False
self.old_wid = self.wid
self.old_thisfile = self.fm.thisfile
self._calc_bar()
self._print_result(self.result)
if self.wid > 2:
self.color('in_titlebar', 'throbber')
self.addnstr(self.y, self.wid - self.right_sumsize, self.throbber, 1)
def click(self, event):
"""Handle a MouseEvent"""
direction = event.mouse_wheel_direction()
if direction:
self.fm.tab_move(direction)
self.need_redraw = True
return True
if not event.pressed(1) or not self.result:
return False
pos = self.wid - 1
for tabname in reversed(self.fm.get_tab_list()):
tabtext = self._get_tab_text(tabname)
pos -= len(tabtext)
if event.x > pos:
self.fm.tab_open(tabname)
self.need_redraw = True
return True
pos = 0
for i, part in enumerate(self.result):
pos += len(part)
if event.x < pos:
if self.settings.hostname_in_titlebar and i <= 2:
self.fm.enter_dir("~")
else:
if 'directory' in part.__dict__:
self.fm.enter_dir(part.directory)
return True
return False
def _calc_bar(self):
bar = Bar('in_titlebar')
self._get_left_part(bar)
self._get_right_part(bar)
try:
bar.shrink_from_the_left(self.wid)
except ValueError:
bar.shrink_by_removing(self.wid)
self.right_sumsize = bar.right.sumsize()
self.result = bar.combine()
def _get_left_part(self, bar):
# TODO: Properly escape non-printable chars without breaking unicode
if self.settings.hostname_in_titlebar:
if self.fm.username == 'root':
clr = 'bad'
else:
clr = 'good'
bar.add(self.fm.username, 'hostname', clr, fixed=True)
bar.add('@', 'hostname', clr, fixed=True)
bar.add(self.fm.hostname, 'hostname', clr, fixed=True)
bar.add(' ', 'hostname', clr, fixed=True)
if self.fm.thisdir:
pathway = self.fm.thistab.pathway
if self.settings.tilde_in_titlebar \
and (self.fm.thisdir.path.startswith(
self.fm.home_path + "/") or self.fm.thisdir.path == self.fm.home_path):
pathway = pathway[self.fm.home_path.count('/') + 1:]
bar.add('~/', 'directory', fixed=True)
for path in pathway:
if path.is_link:
clr = 'link'
else:
clr = 'directory'
bidi_basename = self.bidi_transpose(path.basename)
bar.add(bidi_basename, clr, directory=path)
bar.add('/', clr, fixed=True, directory=path)
if self.fm.thisfile is not None and \
self.settings.show_selection_in_titlebar:
bidi_file_path = self.bidi_transpose(self.fm.thisfile.relative_path)
bar.add(bidi_file_path, 'file')
else:
path = self.fm.thistab.path
if self.settings.tilde_in_titlebar \
and (self.fm.thistab.path.startswith(
self.fm.home_path + "/") or self.fm.thistab.path == self.fm.home_path):
path = path[len(self.fm.home_path + "/"):]
bar.add('~/', 'directory', fixed=True)
clr = 'directory'
bar.add(path, clr, directory=path)
bar.add('/', clr, fixed=True, directory=path)
def _get_right_part(self, bar):
# TODO: fix that pressed keys are cut off when chaining CTRL keys
kbuf = str(self.fm.ui.keybuffer)
self.old_keybuffer = kbuf
bar.addright(' ', 'space', fixed=True)
bar.addright(kbuf, 'keybuffer', fixed=True)
bar.addright(' ', 'space', fixed=True)
if len(self.fm.tabs) > 1:
for tabname in self.fm.get_tab_list():
tabtext = self._get_tab_text(tabname)
clr = 'good' if tabname == self.fm.current_tab else 'bad'
bar.addright(tabtext, 'tab', clr, fixed=True)
def _get_tab_text(self, tabname):
result = ' ' + str(tabname)
if self.settings.dirname_in_tabs:
dirname = basename(self.fm.tabs[tabname].path)
if not dirname:
result += ":/"
elif len(dirname) > 15:
result += ":" + dirname[:14] + self.ellipsis[self.settings.unicode_ellipsis]
else:
result += ":" + dirname
return result
def _print_result(self, result):
self.win.move(0, 0)
for part in result:
self.color(*part.lst)
y, x = self.win.getyx()
self.addstr(y, x, str(part))
self.color_reset()
| 6,051 | Python | .py | 143 | 30.643357 | 92 | 0.552023 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
705 | console.py | ranger_ranger/ranger/gui/widgets/console.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The Console widget implements a vim-like console"""
from __future__ import (absolute_import, division, print_function)
import curses
import os
import re
from collections import deque
from io import open
from ranger import PY3
from ranger.gui.widgets import Widget
from ranger.ext.direction import Direction
from ranger.ext.widestring import uwid, WideString
from ranger.container.history import History, HistoryEmptyException
import ranger
class Console(Widget): # pylint: disable=too-many-instance-attributes,too-many-public-methods
visible = False
last_cursor_mode = None
history_search_pattern = None
prompt = ':'
copy = ''
tab_deque = None
original_line = None
history = None
history_backup = None
override = None
allow_close = False
historypath = None
wait_for_command_input = False
unicode_buffer = ""
def __init__(self, win):
Widget.__init__(self, win)
self.pos = 0
self.line = ''
self.history = History(self.settings.max_console_history_size)
# load history from files
if not ranger.args.clean:
self.historypath = self.fm.datapath('history')
if os.path.exists(self.historypath):
try:
with open(self.historypath, "r", encoding="utf-8") as fobj:
try:
for line in fobj:
self.history.add(line[:-1])
except UnicodeDecodeError as ex:
self.fm.notify(
"Failed to parse corrupt history file",
bad=True,
exception=ex,
)
except (OSError, IOError) as ex:
self.fm.notify(
"Failed to read history file", bad=True, exception=ex
)
self.history_backup = History(self.history)
# NOTE: the console is considered in the "question mode" when the
# question_queue is non-empty. In that case, the console will draw the
# question instead of the regular console, and the input you give is
# used to answer the question instead of typing in commands.
#
# A question is a tuple of (question_string, callback_func,
# tuple_of_choices). callback_func is a function that is called when
# the question is answered which gets the answer as an argument.
# tuple_of_choices looks like ('y', 'n'). Only one-letter-answers are
# currently supported. Pressing enter uses the first choice whereas
# pressing ESC uses the second choice.
self.question_queue = []
def destroy(self):
# save history to files
if ranger.args.clean or not self.settings.save_console_history:
return
if self.historypath:
try:
with open(self.historypath, 'w', encoding="utf-8") as fobj:
for entry in self.history_backup:
try:
fobj.write(entry + '\n')
except UnicodeEncodeError:
pass
except (OSError, IOError) as ex:
self.fm.notify(
"Failed to write history file", bad=True, exception=ex
)
Widget.destroy(self)
def _calculate_offset(self):
wid = self.wid - 2
whalf = wid // 2
if self.pos < whalf or len(self.line) < wid:
return 0
if self.pos > len(self.line) - (wid - whalf):
return len(self.line) - wid
return self.pos - whalf
def draw(self):
self.win.erase()
if self.question_queue:
assert isinstance(self.question_queue[0], tuple)
assert len(self.question_queue[0]) == 3
self.addstr(0, 0, self.question_queue[0][0][self.pos:])
return
self.addstr(0, 0, self.prompt)
line = WideString(self.line)
if line:
x = self._calculate_offset()
self.addstr(0, len(self.prompt), str(line[x:]))
def finalize(self):
move = self.fm.ui.win.move
if self.question_queue:
try:
move(self.y, len(self.question_queue[0][0]))
except curses.error:
pass
else:
try:
x = self._calculate_offset()
pos = uwid(self.line[x:self.pos]) + len(self.prompt)
move(self.y, self.x + min(self.wid - 1, pos))
except curses.error:
pass
def open(self, string='', prompt=None, position=None):
if prompt is not None:
assert isinstance(prompt, str)
self.prompt = prompt
elif 'prompt' in self.__dict__:
del self.prompt
if self.last_cursor_mode is None:
try:
self.last_cursor_mode = curses.curs_set(1)
except curses.error:
pass
self.allow_close = False
self.tab_deque = None
self.unicode_buffer = ""
self.line = string
self.history_search_pattern = self.line
self.pos = len(string)
if position is not None:
self.pos = min(self.pos, position)
self.history_backup.fast_forward()
self.history = History(self.history_backup)
self.history.add('')
self.wait_for_command_input = True
return True
def close(self, trigger_cancel_function=True):
if self.question_queue:
question = self.question_queue[0]
answers = question[2]
if len(answers) >= 2:
self._answer_question(answers[1])
else:
self._close_command_prompt(trigger_cancel_function)
def _close_command_prompt(self, trigger_cancel_function=True):
if trigger_cancel_function:
cmd = self._get_cmd(quiet=True)
if cmd:
cmd.cancel()
if self.last_cursor_mode is not None:
try:
curses.curs_set(self.last_cursor_mode)
except curses.error:
pass
self.last_cursor_mode = None
self.fm.hide_console_info()
self.add_to_history()
self.tab_deque = None
self.clear()
self.__class__ = Console
self.wait_for_command_input = False
def clear(self):
self.pos = 0
self.line = ''
def press(self, key):
self.fm.ui.keymaps.use_keymap('console')
if not self.fm.ui.press(key):
self.type_key(key)
def _answer_question(self, answer):
if not self.question_queue:
return False
question = self.question_queue[0]
_, callback, answers = question
if answer in answers:
self.question_queue.pop(0)
callback(answer)
return True
return False
def type_key(self, key):
self.tab_deque = None
line = "" if self.question_queue else self.line
result = self._add_character(key, self.unicode_buffer, line, self.pos)
if result[1] == line:
# line didn't change, so we don't need to do anything, just update
# the unicode _buffer.
self.unicode_buffer = result[0]
return
if self.question_queue:
self.unicode_buffer, answer, _ = result
self._answer_question(answer)
else:
self.unicode_buffer, self.line, self.pos = result
self.on_line_change()
@staticmethod
def _add_character(key, unicode_buffer, line, pos):
# Takes the pressed key, a string "unicode_buffer" containing a
# potentially incomplete unicode character, the current line and the
# position of the cursor inside the line.
# This function returns the new unicode buffer, the modified line and
# position.
if isinstance(key, int):
try:
key = chr(key)
except ValueError:
return unicode_buffer, line, pos
if PY3:
if len(unicode_buffer) >= 4:
unicode_buffer = ""
if ord(key) in range(0, 256):
unicode_buffer += key
try:
decoded = unicode_buffer.encode("latin-1").decode("utf-8")
except UnicodeDecodeError:
return unicode_buffer, line, pos
except UnicodeEncodeError:
return unicode_buffer, line, pos
else:
unicode_buffer = ""
if pos == len(line):
line += decoded
else:
line = line[:pos] + decoded + line[pos:]
pos += len(decoded)
else:
if pos == len(line):
line += key
else:
line = line[:pos] + key + line[pos:]
pos += len(key)
return unicode_buffer, line, pos
def history_move(self, n):
try:
current = self.history.current()
except HistoryEmptyException:
pass
else:
if self.line != current and self.line != self.history.top():
self.history.modify(self.line)
if self.history_search_pattern:
self.history.search(self.history_search_pattern, n)
else:
self.history.move(n)
current = self.history.current()
if self.line != current:
self.line = self.history.current()
self.pos = len(self.line)
def add_to_history(self):
self.history_backup.fast_forward()
self.history_backup.add(self.line)
self.history = History(self.history_backup)
def move(self, **keywords):
direction = Direction(keywords)
if direction.horizontal():
# Ensure that the pointer is moved utf-char-wise
if PY3:
if self.question_queue:
umax = len(self.question_queue[0][0]) + 1 - self.wid
else:
umax = len(self.line) + 1
self.pos = direction.move(
direction=direction.right(),
minimum=0,
maximum=umax,
current=self.pos)
else:
if self.question_queue:
uchar = list(self.question_queue[0][0].decode('utf-8', 'ignore'))
upos = len(self.question_queue[0][0][:self.pos].decode('utf-8', 'ignore'))
umax = len(uchar) + 1 - self.wid
else:
uchar = list(self.line.decode('utf-8', 'ignore'))
upos = len(self.line[:self.pos].decode('utf-8', 'ignore'))
umax = len(uchar) + 1
newupos = direction.move(
direction=direction.right(),
minimum=0,
maximum=umax,
current=upos)
self.pos = len(''.join(uchar[:newupos]).encode('utf-8', 'ignore'))
def move_word(self, **keywords):
direction = Direction(keywords)
if direction.horizontal():
self.pos = self.move_by_word(self.line, self.pos, direction.right())
self.on_line_change()
@staticmethod
def move_by_word(line, position, direction):
"""
Returns a new position by moving word-wise in the line
>>> from ranger import PY3
>>> if PY3:
... line = "\\u30AA\\u30CF\\u30E8\\u30A6 world, this is dog"
... else:
... # Didn't get the unicode test to work on python2, even though
... # it works fine in ranger, even with unicode input...
... line = "ohai world, this is dog"
>>> Console.move_by_word(line, 0, -1)
0
>>> Console.move_by_word(line, 0, 1)
5
>>> Console.move_by_word(line, 2, -1)
0
>>> Console.move_by_word(line, 2, 1)
5
>>> Console.move_by_word(line, 15, -2)
5
>>> Console.move_by_word(line, 15, 2)
21
>>> Console.move_by_word(line, 24, -1)
21
>>> Console.move_by_word(line, 24, 1)
24
"""
word_beginnings = []
seen_whitespace = True
current_word = None
cursor_inside_word = False
# Scan the line for word boundaries and determine position of cursor
for i, char in enumerate(line):
if i == position:
current_word = len(word_beginnings)
if not seen_whitespace:
cursor_inside_word = True
if char == " ":
seen_whitespace = True
elif seen_whitespace:
seen_whitespace = False
word_beginnings.append(i)
word_beginnings.append(len(line))
# Handle corner cases:
if current_word is None:
current_word = len(word_beginnings)
if direction > 0 and cursor_inside_word:
current_word -= 1
if direction < 0 and position == len(line):
current_word -= 1
new_word = current_word + direction
new_word = max(0, min(len(word_beginnings) - 1, new_word))
return word_beginnings[new_word]
def delete_rest(self, direction):
self.tab_deque = None
if direction > 0:
self.copy = self.line[self.pos:]
self.line = self.line[:self.pos]
else:
self.copy = self.line[:self.pos]
self.line = self.line[self.pos:]
self.pos = 0
self.on_line_change()
def paste(self):
if self.pos == len(self.line):
self.line += self.copy
else:
self.line = self.line[:self.pos] + self.copy + self.line[self.pos:]
self.pos += len(self.copy)
self.on_line_change()
def delete_word(self, backward=True):
if self.line:
self.tab_deque = None
if backward:
right_part = self.line[self.pos:]
i = self.pos - 2
while i >= 0 and re.match(
r'[\w\d]', self.line[i], re.UNICODE): # pylint: disable=no-member
i -= 1
self.copy = self.line[i + 1:self.pos]
self.line = self.line[:i + 1] + right_part
self.pos = i + 1
else:
left_part = self.line[:self.pos]
i = self.pos + 1
while i < len(self.line) and re.match(
r'[\w\d]', self.line[i], re.UNICODE): # pylint: disable=no-member
i += 1
self.copy = self.line[self.pos:i]
if i >= len(self.line):
self.line = left_part
self.pos = len(self.line)
else:
self.line = left_part + self.line[i:]
self.pos = len(left_part)
self.on_line_change()
def delete(self, mod):
self.tab_deque = None
if mod == -1 and self.pos == 0:
if not self.line:
self.close(trigger_cancel_function=False)
return
# Delete utf-char-wise
if PY3:
left_part = self.line[:self.pos + mod]
self.pos = len(left_part)
self.line = left_part + self.line[self.pos + 1:]
else:
uchar = list(self.line.decode('utf-8', 'ignore'))
upos = len(self.line[:self.pos].decode('utf-8', 'ignore')) + mod
left_part = ''.join(uchar[:upos]).encode('utf-8', 'ignore')
self.pos = len(left_part)
self.line = left_part + ''.join(uchar[upos + 1:]).encode('utf-8', 'ignore')
self.on_line_change()
def transpose_subr(self, line, x, y):
# Transpose substrings x & y of line
# x & y are tuples of length two containing positions of endpoints
if not 0 <= x[0] < x[1] <= y[0] < y[1] <= len(line):
self.fm.notify("Tried to transpose invalid regions.", bad=True)
return line
line_begin = line[:x[0]]
word_x = line[x[0]:x[1]]
line_middle = line[x[1]:y[0]]
word_y = line[y[0]:y[1]]
line_end = line[y[1]:]
line = line_begin + word_y + line_middle + word_x + line_end
return line
def transpose_chars(self):
if self.pos == 0:
return
elif self.pos == len(self.line):
x = max(0, self.pos - 2), max(0, self.pos - 1)
y = max(0, self.pos - 1), self.pos
else:
x = max(0, self.pos - 1), self.pos
y = self.pos, min(len(self.line), self.pos + 1)
self.line = self.transpose_subr(self.line, x, y)
self.pos = y[1]
self.on_line_change()
def transpose_words(self):
# Interchange adjacent words at the console with Alt-t
# like in Emacs and many terminal emulators
if self.line:
# If before the first word, interchange next two words
if not re.search(r'[\w\d]', self.line[:self.pos], re.UNICODE):
self.pos = self.move_by_word(self.line, self.pos, 1)
# If in/after last word, interchange last two words
if (re.match(r'[\w\d]*\s*$', self.line[self.pos:], re.UNICODE)
and (re.match(r'[\w\d]', self.line[self.pos - 1], re.UNICODE)
if self.pos - 1 >= 0 else True)):
self.pos = self.move_by_word(self.line, self.pos, -1)
# Util function to increment position until out of word/whitespace
def _traverse(line, pos, regex):
while pos < len(line) and re.match(
regex, line[pos], re.UNICODE):
pos += 1
return pos
# Calculate endpoints of target words and pass them to
# 'self.transpose_subr'
x_begin = self.move_by_word(self.line, self.pos, -1)
x_end = _traverse(self.line, x_begin, r'[\w\d]')
x = x_begin, x_end
y_begin = self.pos
# If in middle of word, move to end
if re.match(r'[\w\d]', self.line[self.pos - 1], re.UNICODE):
y_begin = _traverse(self.line, y_begin, r'[\w\d]')
# Traverse whitespace to beginning of next word
y_begin = _traverse(self.line, y_begin, r'\s')
y_end = _traverse(self.line, y_begin, r'[\w\d]')
y = y_begin, y_end
self.line = self.transpose_subr(self.line, x, y)
self.pos = y[1]
self.on_line_change()
def execute(self, cmd=None):
if self.question_queue and cmd is None:
question = self.question_queue[0]
answers = question[2]
if len(answers) >= 1:
self._answer_question(answers[0])
else:
self.question_queue.pop(0)
return
self.allow_close = True
if cmd:
cmd.execute()
else:
self.fm.execute_console(self.line)
if self.allow_close:
self._close_command_prompt(trigger_cancel_function=False)
def _get_cmd(self, quiet=False):
try:
command_class = self.get_cmd_class()
except IndexError:
return None
except KeyError:
if not quiet:
self.fm.notify("Command not found: `%s'" % self.line.split()[0], bad=True)
return None
return command_class(self.line)
def get_cmd_class(self):
return self.fm.commands.get_command(self.line.split()[0], abbrev=True)
def _get_tab(self, tabnum):
if ' ' in self.line:
cmd = self._get_cmd()
if cmd:
return cmd.tab(tabnum)
return None
return self.fm.commands.command_generator(self.line)
def tab(self, tabnum=1):
if self.tab_deque is None:
tab_result = self._get_tab(tabnum)
if tab_result is None:
pass
elif isinstance(tab_result, str):
self.line = tab_result
self.pos = len(tab_result)
self.on_line_change()
elif hasattr(tab_result, '__iter__'):
self.tab_deque = deque(tab_result)
self.tab_deque.appendleft(self.line)
if self.tab_deque is not None:
self.tab_deque.rotate(-tabnum)
self.line = self.tab_deque[0]
self.pos = len(self.line)
self.on_line_change()
def on_line_change(self):
self.history_search_pattern = self.line
try:
cls = self.get_cmd_class()
except (KeyError, ValueError, IndexError):
pass
else:
cmd = cls(self.line)
if cmd and cmd.quick():
cmd.quickly_executed = True
self.execute(cmd)
def ask(self, text, callback, choices=None):
"""Open a question prompt with predefined choices
The "text" is displayed as the question text and should include a list
of possible keys that the user can type. The "callback" is a function
that is called when the question is answered. It only gets the answer
as an argument. "choices" is a tuple of one-letter strings that can be
typed in by the user. Every other input gets ignored, except <Enter>
and <ESC>.
The first choice is used when the user presses <Enter>, the second
choice is used when the user presses <ESC>.
"""
self.question_queue.append(
(text, callback, choices if choices is not None else ['y', 'n']))
if __name__ == '__main__':
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 22,229 | Python | .py | 544 | 28.705882 | 94 | 0.5368 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
706 | browsercolumn.py | ranger_ranger/ranger/gui/widgets/browsercolumn.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The BrowserColumn widget displays the contents of a directory or file."""
from __future__ import (absolute_import, division, print_function)
import curses
import stat
from time import time
from os.path import splitext
from ranger.ext.widestring import WideString
from ranger.core import linemode
from . import Widget
from .pager import Pager
def hook_before_drawing(fsobject, color_list):
return fsobject, color_list
class BrowserColumn(Pager): # pylint: disable=too-many-instance-attributes
main_column = False
display_infostring = False
display_vcsstate = True
scroll_begin = 0
target = None
last_redraw_time = -1
old_dir = None
old_thisfile = None
def __init__(self, win, level, tab=None):
"""Initializes a Browser Column Widget
win = the curses window object of the BrowserView
level = what to display?
level >0 => previews
level 0 => current file/directory
level <0 => parent directories
"""
self.need_redraw = False
self.image = None
self.need_clear_image = True
Pager.__init__(self, win)
Widget.__init__(self, win) # pylint: disable=non-parent-init-called
self.level = level
self.tab = tab
self.original_level = level
self.settings.signal_bind('setopt.display_size_in_main_column',
self.request_redraw, weak=True)
def request_redraw(self):
self.need_redraw = True
def click(self, event): # pylint: disable=too-many-branches
"""Handle a MouseEvent"""
direction = event.mouse_wheel_direction()
if not (event.pressed(1) or event.pressed(3) or direction):
return False
if self.target is None:
pass
elif self.target.is_directory:
if self.target.accessible and self.target.content_loaded:
index = self.scroll_begin + event.y - self.y
if direction:
if self.level == -1:
self.fm.move_parent(direction)
else:
return False
elif event.pressed(1):
if not self.main_column:
self.fm.enter_dir(self.target.path)
if index < len(self.target):
self.fm.move(to=index)
elif event.pressed(3):
try:
clicked_file = self.target.files[index]
except IndexError:
pass
else:
if clicked_file.is_directory:
self.fm.enter_dir(clicked_file.path, remember=True)
elif self.level == 0:
self.fm.thisdir.move_to_obj(clicked_file)
self.fm.execute_file(clicked_file)
elif self.target.is_file:
if event.pressed(3):
self.fm.execute_file(self.target)
else:
self.scrollbit(direction)
else:
if self.level > 0 and not direction:
self.fm.move(right=0)
return True
def execute_curses_batch(self, line, commands):
"""Executes a list of "commands" which can be easily cached.
"commands" is a list of lists. Each element contains
a text and an attribute. First, the attribute will be
set with attrset, then the text is printed.
Example:
execute_curses_batch(0, [["hello ", 0], ["world", curses.A_BOLD]])
"""
try:
self.win.move(line, 0)
except curses.error:
return
for entry in commands:
text, attr = entry
self.addstr(text, attr)
def has_preview(self):
if self.target is None:
return False
if self.target.is_file:
if not self.target.has_preview():
return False
if self.target.is_directory:
if self.level > 0 and not self.settings.preview_directories:
return False
return True
def level_shift(self, amount):
self.level = self.original_level + amount
def level_restore(self):
self.level = self.original_level
def poke(self):
Widget.poke(self)
if self.tab is None:
tab = self.fm.thistab
else:
tab = self.tab
self.target = tab.at_level(self.level)
def draw(self):
"""Call either _draw_file() or _draw_directory()"""
target = self.target
if target != self.old_dir:
self.need_redraw = True
self.old_dir = target
self.scroll_extra = 0 # reset scroll start
if target:
target.use()
if target.is_directory and (self.level <= 0 or self.settings.preview_directories):
if self.old_thisfile != target.pointed_obj:
self.old_thisfile = target.pointed_obj
self.need_redraw = True
self.need_redraw |= target.load_content_if_outdated()
self.need_redraw |= target.sort_if_outdated()
self.need_redraw |= self.last_redraw_time < target.last_update_time
if target.pointed_obj:
self.need_redraw |= target.pointed_obj.load_if_outdated()
self.need_redraw |= self.last_redraw_time < target.pointed_obj.last_load_time
else:
self.need_redraw |= target.load_if_outdated()
self.need_redraw |= self.last_redraw_time < target.last_load_time
if self.need_redraw:
self.win.erase()
if target is None:
pass
elif target.is_file:
Pager.open(self)
self._draw_file()
elif target.is_directory:
self._draw_directory()
Widget.draw(self)
self.need_redraw = False
self.last_redraw_time = time()
def _draw_file(self):
"""Draw a preview of the file, if the settings allow it"""
self.win.move(0, 0)
if self.target is None or not self.target.has_preview():
Pager.close(self)
return
if not self.target.accessible:
self.addnstr("not accessible", self.wid)
Pager.close(self)
return
path = self.target.get_preview_source(self.wid, self.hei)
if path is None:
Pager.close(self)
else:
if self.target.is_image_preview():
self.set_image(path)
else:
self.set_source(path)
Pager.draw(self)
def _format_line_number(self, linum_format, i, selected_i):
line_number = i
if self.settings.line_numbers.lower() == 'relative':
line_number = abs(selected_i - i)
if not self.settings.relative_current_zero and line_number == 0:
if self.settings.one_indexed:
line_number = selected_i + 1
else:
line_number = selected_i
elif self.settings.one_indexed:
line_number += 1
return linum_format.format(line_number)
def _draw_directory( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
self):
"""Draw the contents of a directory"""
if self.image:
self.image = None
self.need_clear_image = True
Pager.clear_image(self)
if self.level > 0 and not self.settings.preview_directories:
return
base_color = ['in_browser']
if self.fm.ui.viewmode == 'multipane' and self.tab is not None:
active_pane = self.tab == self.fm.thistab
if active_pane:
base_color.append('active_pane')
else:
base_color.append('inactive_pane')
else:
active_pane = False
self.win.move(0, 0)
if not self.target.content_loaded:
self.color(tuple(base_color))
self.addnstr("...", self.wid)
self.color_reset()
return
if self.main_column:
base_color.append('main_column')
if not self.target.accessible:
self.color(tuple(base_color + ['error']))
self.addnstr("not accessible", self.wid)
self.color_reset()
return
if self.target.empty():
self.color(tuple(base_color + ['empty']))
self.addnstr("empty", self.wid)
self.color_reset()
return
self._set_scroll_begin()
copied = [f.path for f in self.fm.copy_buffer]
selected_i = self._get_index_of_selected_file()
# Set the size of the linum text field to the number of digits in the
# visible files in directory.
def nr_of_digits(number):
return len(str(number))
scroll_end = self.scroll_begin + min(self.hei, len(self.target)) - 1
distance_to_top = selected_i - self.scroll_begin
distance_to_bottom = scroll_end - selected_i
one_indexed_offset = 1 if self.settings.one_indexed else 0
if self.settings.line_numbers.lower() == "relative":
linum_text_len = nr_of_digits(max(distance_to_top,
distance_to_bottom))
if not self.settings.relative_current_zero:
linum_text_len = max(nr_of_digits(selected_i
+ one_indexed_offset),
linum_text_len)
else:
linum_text_len = nr_of_digits(scroll_end + one_indexed_offset)
linum_format = "{0:>" + str(linum_text_len) + "}"
for line in range(self.hei):
i = line + self.scroll_begin
try:
drawn = self.target.files[i]
except IndexError:
break
tagged = self.fm.tags and drawn.realpath in self.fm.tags
if tagged:
tagged_marker = self.fm.tags.marker(drawn.realpath)
else:
tagged_marker = " "
# Extract linemode-related information from the drawn object
metadata = None
current_linemode = drawn.linemode_dict[drawn.linemode]
if current_linemode.uses_metadata:
metadata = self.fm.metadata.get_metadata(drawn.path)
if not all(getattr(metadata, tag)
for tag in current_linemode.required_metadata):
current_linemode = drawn.linemode_dict[linemode.DEFAULT_LINEMODE]
metakey = hash(repr(sorted(metadata.items()))) if metadata else 0
key = (self.wid, selected_i == i, drawn.marked, self.main_column,
drawn.path in copied, tagged_marker, drawn.infostring,
drawn.vcsstatus, drawn.vcsremotestatus, self.target.has_vcschild,
self.fm.do_cut, current_linemode.name, metakey, active_pane,
self.settings.line_numbers.lower(), linum_text_len)
# Check if current line has not already computed and cached
if key in drawn.display_data:
# Recompute line numbers because they can't be reliably cached.
if (
self.main_column
and self.settings.line_numbers.lower() != 'false'
):
line_number_text = self._format_line_number(linum_format,
i,
selected_i)
drawn.display_data[key][0][0] = line_number_text
self.execute_curses_batch(line, drawn.display_data[key])
self.color_reset()
continue
text = current_linemode.filetitle(drawn, metadata)
if drawn.marked and (self.main_column
or self.settings.display_tags_in_all_columns):
text = " " + text
# Computing predisplay data. predisplay contains a list of lists
# [string, colorlst] where string is a piece of string to display,
# and colorlst a list of contexts that we later pass to the
# colorscheme, to compute the curses attribute.
predisplay_left = []
predisplay_right = []
space = self.wid
# line number field
if self.settings.line_numbers.lower() != 'false':
if self.main_column and space - linum_text_len > 2:
line_number_text = self._format_line_number(linum_format,
i,
selected_i)
predisplay_left.append([line_number_text, ['line_number']])
space -= linum_text_len
# Delete one additional character for space separator
# between the line number and the tag
space -= 1
# add separator between line number and tag
predisplay_left.append([' ', []])
# selection mark
tagmark = self._draw_tagged_display(tagged, tagged_marker)
tagmarklen = self._total_len(tagmark)
if space - tagmarklen > 2:
predisplay_left += tagmark
space -= tagmarklen
# vcs data
vcsstring = self._draw_vcsstring_display(drawn)
vcsstringlen = self._total_len(vcsstring)
if space - vcsstringlen > 2:
predisplay_right += vcsstring
space -= vcsstringlen
# info string
infostring = []
infostringlen = 0
try:
infostringdata = current_linemode.infostring(drawn, metadata)
if infostringdata:
infostring.append([" " + infostringdata,
["infostring"]])
except NotImplementedError:
infostring = self._draw_infostring_display(drawn, space)
if infostring:
infostringlen = self._total_len(infostring)
if space - infostringlen > 2:
sep = [[" ", []]] if predisplay_right else []
predisplay_right = infostring + sep + predisplay_right
space -= infostringlen + len(sep)
textstring = self._draw_text_display(text, space)
textstringlen = self._total_len(textstring)
predisplay_left += textstring
space -= textstringlen
assert space >= 0, "Error: there is not enough space to write the text. " \
"I have computed spaces wrong."
if space > 0:
predisplay_left.append([' ' * space, []])
# Computing display data. Now we compute the display_data list
# ready to display in curses. It is a list of lists [string, attr]
this_color = base_color + list(drawn.mimetype_tuple) + \
self._draw_directory_color(i, drawn, copied)
display_data = []
drawn.display_data[key] = display_data
drawn, this_color = hook_before_drawing(drawn, this_color)
predisplay = predisplay_left + predisplay_right
for txt, color in predisplay:
attr = self.settings.colorscheme.get_attr(*(this_color + color))
display_data.append([txt, attr])
self.execute_curses_batch(line, display_data)
self.color_reset()
def _get_index_of_selected_file(self):
if self.fm.ui.viewmode == 'multipane' and self.tab != self.fm.thistab:
return self.tab.pointer
return self.target.pointer
@staticmethod
def _total_len(predisplay):
return sum(len(WideString(s)) for s, _ in predisplay)
def _draw_text_display(self, text, space):
bidi_text = self.bidi_transpose(text)
wtext = WideString(bidi_text)
wext = WideString(splitext(bidi_text)[1])
wellip = WideString(self.ellipsis[self.settings.unicode_ellipsis])
if len(wtext) > space:
wtext = wtext[:max(1, space - len(wext) - len(wellip))] + wellip + wext
# Truncate again if still too long.
if len(wtext) > space:
wtext = wtext[:max(0, space - len(wellip))] + wellip
return [[str(wtext), []]]
def _draw_tagged_display(self, tagged, tagged_marker):
tagged_display = []
if (self.main_column or self.settings.display_tags_in_all_columns) \
and self.wid > 2:
if tagged:
tagged_display.append([tagged_marker, ['tag_marker']])
else:
tagged_display.append([" ", ['tag_marker']])
return tagged_display
def _draw_infostring_display(self, drawn, space):
infostring_display = []
if self.display_infostring and drawn.infostring \
and self.settings.display_size_in_main_column:
infostring = str(drawn.infostring)
if len(infostring) <= space:
infostring_display.append([infostring, ['infostring']])
return infostring_display
def _draw_vcsstring_display(self, drawn):
vcsstring_display = []
if (self.target.vcs and self.target.vcs.track) \
or (drawn.is_directory and drawn.vcs and drawn.vcs.track):
if drawn.vcsremotestatus:
vcsstr, vcscol = self.vcsremotestatus_symb[drawn.vcsremotestatus]
vcsstring_display.append([vcsstr, ['vcsremote'] + vcscol])
elif self.target.has_vcschild:
vcsstring_display.append([' ', []])
if drawn.vcsstatus:
vcsstr, vcscol = self.vcsstatus_symb[drawn.vcsstatus]
vcsstring_display.append([vcsstr, ['vcsfile'] + vcscol])
elif self.target.has_vcschild:
vcsstring_display.append([' ', []])
elif self.target.has_vcschild:
vcsstring_display.append([' ', []])
return vcsstring_display
def _draw_directory_color(self, i, drawn, copied):
this_color = []
if i == self._get_index_of_selected_file():
this_color.append('selected')
if drawn.marked:
this_color.append('marked')
if self.fm.tags and drawn.realpath in self.fm.tags:
this_color.append('tagged')
if drawn.is_directory:
this_color.append('directory')
else:
this_color.append('file')
if drawn.stat:
mode = drawn.stat.st_mode
if mode & stat.S_IXUSR:
this_color.append('executable')
if stat.S_ISFIFO(mode):
this_color.append('fifo')
if stat.S_ISSOCK(mode):
this_color.append('socket')
if drawn.is_device:
this_color.append('device')
if drawn.path in copied:
this_color.append('cut' if self.fm.do_cut else 'copied')
if drawn.is_link:
this_color.append('link')
this_color.append(drawn.exists and 'good' or 'bad')
return this_color
def _get_scroll_begin(self): # pylint: disable=too-many-return-statements
"""Determines scroll_begin (the position of the first displayed file)"""
offset = self.settings.scroll_offset
dirsize = len(self.target)
winsize = self.hei
halfwinsize = winsize // 2
index = self._get_index_of_selected_file() or 0
original = self.target.scroll_begin
projected = index - original
upper_limit = winsize - 1 - offset
lower_limit = offset
if original < 0:
return 0
if dirsize < winsize:
return 0
if halfwinsize < offset:
return min(dirsize - winsize, max(0, index - halfwinsize))
if original > dirsize - winsize:
self.target.scroll_begin = dirsize - winsize
return self._get_scroll_begin()
if lower_limit < projected < upper_limit:
return original
if projected > upper_limit:
return min(dirsize - winsize, original + (projected - upper_limit))
if projected < upper_limit:
return max(0, original - (lower_limit - projected))
return original
def _set_scroll_begin(self):
"""Updates the scroll_begin value"""
self.scroll_begin = self._get_scroll_begin()
self.target.scroll_begin = self.scroll_begin
def scroll(self, n):
"""scroll down by n lines"""
self.need_redraw = True
self.target.move(down=n)
self.target.scroll_begin += 3 * n
def __str__(self):
return self.__class__.__name__ + ' at level ' + str(self.level)
| 21,365 | Python | .py | 471 | 31.951168 | 97 | 0.557271 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
707 | taskview.py | ranger_ranger/ranger/gui/widgets/taskview.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The TaskView allows you to modify what the loader is doing."""
from __future__ import (absolute_import, division, print_function)
from ranger.ext.accumulator import Accumulator
from . import Widget
class TaskView(Widget, Accumulator):
old_lst = None
def __init__(self, win):
Widget.__init__(self, win)
Accumulator.__init__(self)
self.scroll_begin = 0
def draw(self):
base_clr = []
base_clr.append('in_taskview')
lst = self.get_list()
if self.old_lst != lst:
self.old_lst = lst
self.need_redraw = True
if self.need_redraw:
self.win.erase()
if not self.pointer_is_synced():
self.sync_index()
if self.hei <= 0:
return
self.addstr(0, 0, "Task View")
self.color_at(0, 0, self.wid, tuple(base_clr), 'title')
if lst:
for i in range(self.hei - 1):
i += self.scroll_begin
try:
obj = lst[i]
except IndexError:
break
y = i + 1
clr = list(base_clr)
if self.pointer == i:
clr.append('selected')
descr = obj.get_description()
if obj.progressbar_supported and obj.percent >= 0 and obj.percent <= 100:
self.addstr(y, 0, "%3.2f%% - %s" % (obj.percent, descr), self.wid)
wid = int((self.wid / 100) * obj.percent)
self.color_at(y, 0, self.wid, tuple(clr))
self.color_at(y, 0, wid, tuple(clr), 'loaded')
else:
self.addstr(y, 0, descr, self.wid)
self.color_at(y, 0, self.wid, tuple(clr))
else:
if self.hei > 1:
self.addstr(1, 0, "No task in the queue.")
self.color_at(1, 0, self.wid, tuple(base_clr), 'error')
self.color_reset()
def finalize(self):
y = self.y + 1 + self.pointer - self.scroll_begin
self.fm.ui.win.move(y, self.x)
def task_remove(self, i=None):
if i is None:
i = self.pointer
if self.fm.loader.queue:
self.fm.loader.remove(index=i)
def task_move(self, to, i=None): # pylint: disable=invalid-name
if i is None:
i = self.pointer
self.fm.loader.move(pos_src=i, pos_dest=to)
def press(self, key):
self.fm.ui.keymaps.use_keymap('taskview')
self.fm.ui.press(key)
def get_list(self):
return self.fm.loader.queue
| 2,876 | Python | .py | 69 | 28.376812 | 93 | 0.507908 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
708 | statusbar.py | ranger_ranger/ranger/gui/widgets/statusbar.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The statusbar displays information about the current file and directory.
On the left side, there is a display similar to what "ls -l" would
print for the current file. The right side shows directory information
such as the space used by all the files in this directory.
"""
from __future__ import (absolute_import, division, print_function)
import curses
import os
from os import getuid, readlink
from pwd import getpwuid
from grp import getgrgid
from time import time, strftime, localtime
from ranger.ext.human_readable import human_readable
from ranger.gui.bar import Bar
from . import Widget
class StatusBar(Widget): # pylint: disable=too-many-instance-attributes
__doc__ = __doc__
owners = {}
groups = {}
timeformat = '%Y-%m-%d %H:%M'
hint = None
msg = None
old_thisfile = None
old_ctime = None
old_du = None
old_hint = None
result = None
def __init__(self, win, column=None):
Widget.__init__(self, win)
self.column = column
self.settings.signal_bind('setopt.display_size_in_status_bar',
self.request_redraw, weak=True)
self.fm.signal_bind('tab.layoutchange', self.request_redraw, weak=True)
self.fm.signal_bind('setop.viewmode', self.request_redraw, weak=True)
def request_redraw(self):
self.need_redraw = True
def notify(self, text, duration=0, bad=False):
self.msg = Message(text, duration, bad)
def clear_message(self):
self.msg = None
def draw(self): # pylint: disable=too-many-branches
"""Draw the statusbar"""
if self.column != self.fm.ui.browser.main_column:
self.column = self.fm.ui.browser.main_column
self.need_redraw = True
if self.hint and isinstance(self.hint, str):
if self.old_hint != self.hint:
self.need_redraw = True
if self.need_redraw:
self._draw_hint()
return
if self.old_hint and not self.hint:
self.old_hint = None
self.need_redraw = True
if self.msg:
if self.msg.is_alive():
self._draw_message()
return
else:
self.msg = None
self.need_redraw = True
if self.fm.thisfile:
self.fm.thisfile.load_if_outdated()
try:
ctime = self.fm.thisfile.stat.st_ctime
except AttributeError:
ctime = -1
else:
ctime = -1
if not self.result:
self.need_redraw = True
if self.old_du and not self.fm.thisdir.disk_usage:
self.old_du = self.fm.thisdir.disk_usage
self.need_redraw = True
if self.old_thisfile != self.fm.thisfile:
self.old_thisfile = self.fm.thisfile
self.need_redraw = True
if self.old_ctime != ctime:
self.old_ctime = ctime
self.need_redraw = True
if self.need_redraw:
self.need_redraw = False
self._calc_bar()
self._print_result(self.result)
def _calc_bar(self):
bar = Bar('in_statusbar')
self._get_left_part(bar)
self._get_right_part(bar)
bar.shrink_by_removing(self.wid)
self.result = bar.combine()
def _draw_message(self):
self.win.erase()
self.color('in_statusbar', 'message',
self.msg.bad and 'bad' or 'good')
self.addnstr(0, 0, self.msg.text, self.wid)
def _draw_hint(self):
self.win.erase()
highlight = True
space_left = self.wid
starting_point = self.x
for string in self.hint.split('*'):
highlight = not highlight
if highlight:
self.color('in_statusbar', 'text', 'highlight')
else:
self.color('in_statusbar', 'text')
try:
self.addnstr(0, starting_point, string, space_left)
except curses.error:
break
space_left -= len(string)
starting_point += len(string)
def _get_left_part(self, bar): # pylint: disable=too-many-branches,too-many-statements
left = bar.left
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 AttributeError:
return
if stat is None:
return
if self.fm.mode != 'normal':
perms = '--%s--' % self.fm.mode.upper()
else:
perms = target.get_permission_string()
how = 'good' if getuid() == stat.st_uid else 'bad'
left.add(perms, 'permissions', how)
left.add_space()
left.add(str(stat.st_nlink), 'nlink')
left.add_space()
left.add(self._get_owner(target), 'owner')
left.add_space()
left.add(self._get_group(target), 'group')
if target.is_link:
how = 'good' if target.exists else 'bad'
try:
dest = readlink(target.path)
except OSError:
dest = '?'
left.add(' -> ' + dest, 'link', how)
else:
left.add_space()
if self.settings.display_size_in_status_bar and target.infostring:
left.add(target.infostring.replace(" ", ""))
left.add_space()
try:
date = strftime(self.timeformat, localtime(stat.st_mtime))
except OSError:
date = '?'
left.add(date, 'mtime')
directory = target if target.is_directory else \
target.fm.get_directory(os.path.dirname(target.path))
if directory.vcs and directory.vcs.track:
if directory.vcs.rootvcs.branch:
vcsinfo = '({0:s}: {1:s})'.format(
directory.vcs.rootvcs.repotype, directory.vcs.rootvcs.branch)
else:
vcsinfo = '({0:s})'.format(directory.vcs.rootvcs.repotype)
left.add_space()
left.add(vcsinfo, 'vcsinfo')
left.add_space()
if directory.vcs.rootvcs.obj.vcsremotestatus:
vcsstr, vcscol = self.vcsremotestatus_symb[
directory.vcs.rootvcs.obj.vcsremotestatus]
left.add(vcsstr.strip(), 'vcsremote', *vcscol)
if target.vcsstatus:
vcsstr, vcscol = self.vcsstatus_symb[target.vcsstatus]
left.add(vcsstr.strip(), 'vcsfile', *vcscol)
if directory.vcs.rootvcs.head:
left.add_space()
left.add(directory.vcs.rootvcs.head['date'].strftime(self.timeformat), 'vcsdate')
left.add_space()
summary_length = self.settings.vcs_msg_length or 50
left.add(
directory.vcs.rootvcs.head['summary'][:summary_length],
'vcscommit'
)
def _get_owner(self, target):
uid = target.stat.st_uid
try:
return self.owners[uid]
except KeyError:
try:
self.owners[uid] = getpwuid(uid)[0]
return self.owners[uid]
except KeyError:
return str(uid)
def _get_group(self, target):
gid = target.stat.st_gid
try:
return self.groups[gid]
except KeyError:
try:
self.groups[gid] = getgrgid(gid)[0]
return self.groups[gid]
except KeyError:
return str(gid)
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 _print_result(self, result):
self.win.move(0, 0)
for part in result:
self.color(*part.lst)
self.addstr(str(part))
if self.settings.draw_progress_bar_in_status_bar:
queue = self.fm.loader.queue
states = []
for item in queue:
if item.progressbar_supported:
states.append(item.percent)
if states:
state = sum(states) / len(states)
barwidth = (state / 100) * self.wid
self.color_at(0, 0, int(barwidth), ("in_statusbar", "loaded"))
self.color_reset()
def get_free_space(path):
stat = os.statvfs(path)
return stat.f_bavail * stat.f_frsize
class Message(object): # pylint: disable=too-few-public-methods
elapse = None
text = None
bad = False
def __init__(self, text, duration, bad):
self.text = text
self.bad = bad
self.elapse = time() + duration
def is_alive(self):
return time() <= self.elapse
| 11,934 | Python | .py | 300 | 28.136667 | 97 | 0.54873 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
709 | view_base.py | ranger_ranger/ranger/gui/widgets/view_base.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The base GUI element for views on the directory"""
from __future__ import (absolute_import, division, print_function)
import curses
from ranger.ext.keybinding_parser import key_to_string
from . import Widget
from ..displayable import DisplayableContainer
class ViewBase(Widget, DisplayableContainer): # pylint: disable=too-many-instance-attributes
draw_bookmarks = False
need_clear = False
draw_hints = False
draw_info = False
def __init__(self, win): # pylint: disable=super-init-not-called
DisplayableContainer.__init__(self, win)
self.fm.signal_bind('move', self.request_clear)
self.old_draw_borders = self.settings.draw_borders
self.columns = None
self.main_column = None
self.pager = None
def request_clear(self):
self.need_clear = True
def draw(self):
if self.need_clear:
self.win.erase()
self.need_redraw = True
self.need_clear = False
for tab in self.fm.tabs.values():
directory = tab.thisdir
if directory:
directory.load_content_if_outdated()
directory.use()
DisplayableContainer.draw(self)
if self.draw_bookmarks:
self._draw_bookmarks()
elif self.draw_hints:
self._draw_hints()
elif self.draw_info:
self._draw_info(self.draw_info)
def finalize(self):
if self.pager is not None and self.pager.visible:
try:
self.fm.ui.win.move(self.main_column.y, self.main_column.x)
except curses.error:
pass
else:
col_x = self.main_column.x
col_y = self.main_column.y - self.main_column.scroll_begin
if self.main_column.target:
col_y += self.main_column.target.pointer
try:
self.fm.ui.win.move(col_y, col_x)
except curses.error:
pass
def _draw_bookmarks(self):
self.columns[-1].clear_image(force=True)
self.fm.bookmarks.update_if_outdated()
self.color_reset()
self.need_clear = True
sorted_bookmarks = sorted(
(
item for item in self.fm.bookmarks
if self.fm.settings.show_hidden_bookmarks
or '/.' not in item[1].path
),
key=lambda t: t[0].lower(),
)
hei = min(self.hei - 1, len(sorted_bookmarks))
ystart = self.hei - hei
maxlen = self.wid
self.addnstr(ystart - 1, 0, "mark path".ljust(self.wid), self.wid)
whitespace = " " * maxlen
for line, items in zip(range(self.hei - 1), sorted_bookmarks):
key, mark = items
string = " " + key + " " + mark.path
self.addstr(ystart + line, 0, whitespace)
self.addnstr(ystart + line, 0, string, self.wid)
self.win.chgat(ystart - 1, 0, curses.A_UNDERLINE)
def _draw_info(self, lines):
self.columns[-1].clear_image(force=True)
self.need_clear = True
hei = min(self.hei - 1, len(lines))
ystart = self.hei - hei
i = ystart
whitespace = " " * self.wid
for line in lines:
if i >= self.hei:
break
self.addstr(i, 0, whitespace)
self.addnstr(i, 0, line, self.wid)
i += 1
def _draw_hints(self):
self.columns[-1].clear_image(force=True)
self.color_reset()
self.need_clear = True
hints = []
def populate_hints(keymap, prefix=""):
for key, value in keymap.items():
key = prefix + key_to_string(key)
if isinstance(value, dict):
populate_hints(value, key)
else:
text = value
if text.startswith('hint') or text.startswith('chain hint'):
continue
hints.append((key, text))
populate_hints(self.fm.ui.keybuffer.pointer)
def sort_hints(hints):
"""Sort the hints by the action string but first group them by the
first key.
"""
from itertools import groupby
# groupby needs the list to be sorted.
hints.sort(key=lambda t: t[0])
def group_hints(hints):
def first_key(hint):
return hint[0][0]
def action_string(hint):
return hint[1]
return (sorted(group, key=action_string)
for _, group
in groupby(
hints,
key=first_key))
grouped_hints = group_hints(hints)
# If there are too many hints, collapse the sublists.
if len(hints) > self.fm.settings.hint_collapse_threshold:
def first_key_in_group(group):
return group[0][0][0]
grouped_hints = (
[(first_key_in_group(hint_group), "...")]
if len(hint_group) > 1
else hint_group
for hint_group in grouped_hints
)
# Sort by the first action in group.
grouped_hints = sorted(grouped_hints, key=lambda g: g[0][1])
def flatten(nested_list):
return [item for inner_list in nested_list for item in inner_list]
return flatten(grouped_hints)
hints = sort_hints(hints)
hei = min(self.hei - 1, len(hints))
ystart = self.hei - hei
self.addnstr(ystart - 1, 0, "key command".ljust(self.wid), self.wid)
try:
self.win.chgat(ystart - 1, 0, curses.A_UNDERLINE)
except curses.error:
pass
whitespace = " " * self.wid
i = ystart
for key, cmd in hints:
string = " " + key.ljust(11) + " " + cmd
self.addstr(i, 0, whitespace)
self.addnstr(i, 0, string, self.wid)
i += 1
def click(self, event):
if DisplayableContainer.click(self, event):
return True
direction = event.mouse_wheel_direction()
if direction:
self.main_column.scroll(direction)
return False
def resize(self, y, x, hei=None, wid=None):
DisplayableContainer.resize(self, y, x, hei, wid)
def poke(self):
DisplayableContainer.poke(self)
| 6,679 | Python | .py | 166 | 28.283133 | 93 | 0.546998 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
710 | __init__.py | ranger_ranger/ranger/gui/widgets/__init__.py | # -*- coding: utf-8 -*-
from __future__ import (absolute_import, division, print_function)
from ranger.gui.displayable import Displayable
class Widget(Displayable):
"""A class for classification of widgets."""
vcsstatus_symb = {
'conflict': (
'X', ['vcsconflict']),
'untracked': (
'?', ['vcsuntracked']),
'deleted': (
'-', ['vcschanged']),
'changed': (
'+', ['vcschanged']),
'staged': (
'*', ['vcsstaged']),
'ignored': (
'·', ['vcsignored']),
'sync': (
'✓', ['vcssync']),
'none': (
' ', []),
'unknown': (
'!', ['vcsunknown']),
}
vcsremotestatus_symb = {
'diverged': (
'Y', ['vcsdiverged']),
'ahead': (
'>', ['vcsahead']),
'behind': (
'<', ['vcsbehind']),
'sync': (
'=', ['vcssync']),
'none': (
'⌂', ['vcsnone']),
'unknown': (
'!', ['vcsunknown']),
}
ellipsis = {False: '~', True: '…'}
| 1,123 | Python | .py | 40 | 18.625 | 66 | 0.403181 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
711 | view_multipane.py | ranger_ranger/ranger/gui/widgets/view_multipane.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import curses
from ranger.gui.widgets.view_base import ViewBase
from ranger.gui.widgets.browsercolumn import BrowserColumn
class ViewMultipane(ViewBase): # pylint: disable=too-many-ancestors
def __init__(self, win):
ViewBase.__init__(self, win)
self.fm.signal_bind('tab.layoutchange', self._layoutchange_handler)
self.fm.signal_bind('tab.change', self._tabchange_handler)
self.rebuild()
self.old_draw_borders = self._draw_borders_setting()
def _draw_borders_setting(self):
# If draw_borders_multipane has not been set, it defaults to `None`
# and we fallback to using draw_borders. Important to note:
# `None` is different from the string "none" referring to no borders
if self.settings.draw_borders_multipane is not None:
return self.settings.draw_borders_multipane
else:
return self.settings.draw_borders
def _layoutchange_handler(self):
if self.fm.ui.browser == self:
self.rebuild()
def _tabchange_handler(self, signal):
if self.fm.ui.browser == self:
if signal.old:
signal.old.need_redraw = True
if signal.new:
signal.new.need_redraw = True
def rebuild(self):
self.columns = []
for child in self.container:
self.remove_child(child)
child.destroy()
for name, tab in self.fm.tabs.items():
column = BrowserColumn(self.win, 0, tab=tab)
column.main_column = True
column.display_infostring = True
if name == self.fm.current_tab:
self.main_column = column
self.columns.append(column)
self.add_child(column)
self.resize(self.y, self.x, self.hei, self.wid)
def draw(self):
if self.need_clear:
self.win.erase()
self.need_redraw = True
self.need_clear = False
ViewBase.draw(self)
if self._draw_borders_setting():
draw_borders = self._draw_borders_setting()
if draw_borders in ['both', 'true']: # 'true' for backwards compat.
border_types = ['separators', 'outline']
else:
border_types = [draw_borders]
self._draw_borders(border_types)
if self.draw_bookmarks:
self._draw_bookmarks()
elif self.draw_hints:
self._draw_hints()
elif self.draw_info:
self._draw_info(self.draw_info)
def _draw_border_rectangle(self, left_start, right_end):
win = self.win
win.hline(0, left_start, curses.ACS_HLINE, right_end - left_start)
win.hline(self.hei - 1, left_start, curses.ACS_HLINE, right_end - left_start)
win.vline(1, left_start, curses.ACS_VLINE, self.hei - 2)
win.vline(1, right_end, curses.ACS_VLINE, self.hei - 2)
# Draw the four corners
self.addch(0, left_start, curses.ACS_ULCORNER)
self.addch(self.hei - 1, left_start, curses.ACS_LLCORNER)
self.addch(0, right_end, curses.ACS_URCORNER)
self.addch(self.hei - 1, right_end, curses.ACS_LRCORNER)
def _draw_borders(self, border_types):
# Referenced from ranger.gui.widgets.view_miller
win = self.win
self.color('in_browser', 'border')
left_start = 0
right_end = self.wid - 1
# Draw the outline borders
if 'active-pane' not in border_types:
if 'outline' in border_types:
try:
self._draw_border_rectangle(left_start, right_end)
except curses.error:
pass
# Draw the column separators
if 'separators' in border_types:
for child in self.columns[:-1]:
x = child.x + child.wid
y = self.hei - 1
try:
win.vline(1, x, curses.ACS_VLINE, y - 1)
if 'outline' in border_types:
self.addch(0, x, curses.ACS_TTEE, 0)
self.addch(y, x, curses.ACS_BTEE, 0)
else:
self.addch(0, x, curses.ACS_VLINE, 0)
self.addch(y, x, curses.ACS_VLINE, 0)
except curses.error:
pass
else:
bordered_column = self.main_column
left_start = max(bordered_column.x, 0)
right_end = min(left_start + bordered_column.wid, self.wid - 1)
try:
self._draw_border_rectangle(left_start, right_end)
except curses.error:
pass
def resize(self, y, x, hei=None, wid=None):
ViewBase.resize(self, y, x, hei, wid)
border_type = self._draw_borders_setting()
if border_type in ['outline', 'both', 'true', 'active-pane']:
# 'true' for backwards compat., no height pad needed for 'separators'
pad = 1
else:
pad = 0
column_width = int((wid - len(self.columns) + 1) / len(self.columns))
left = 0
top = 0
for column in self.columns:
column.resize(top + pad, left, hei - pad * 2, max(1, column_width))
left += column_width + 1
column.need_redraw = True
self.need_redraw = True
def poke(self):
ViewBase.poke(self)
if self.old_draw_borders != self._draw_borders_setting():
self.resize(self.y, self.x, self.hei, self.wid)
self.old_draw_borders = self._draw_borders_setting()
| 5,858 | Python | .py | 131 | 32.816794 | 85 | 0.570928 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
712 | pager.py | ranger_ranger/ranger/gui/widgets/pager.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The pager displays text and allows you to scroll inside it."""
from __future__ import (absolute_import, division, print_function)
import curses
import logging
from ranger.gui import ansi
from ranger.ext.direction import Direction
from ranger.ext.img_display import ImgDisplayUnsupportedException
from . import Widget
LOG = logging.getLogger(__name__)
# TODO: Scrolling in embedded pager
class Pager(Widget): # pylint: disable=too-many-instance-attributes
source = None
source_is_stream = False
old_source = None
old_scroll_begin = 0
old_startx = 0
need_clear_image = False
need_redraw_image = False
max_width = None
def __init__(self, win, embedded=False):
Widget.__init__(self, win)
self.embedded = embedded
self.scroll_begin = 0
self.scroll_extra = 0
self.startx = 0
self.markup = None
self.lines = []
self.image = None
self.image_drawn = False
def _close_source(self):
if self.source and self.source_is_stream:
try:
self.source.close()
except OSError as ex:
LOG.error('Unable to close pager source')
LOG.exception(ex)
def open(self):
self.scroll_begin = 0
self.markup = None
self.max_width = 0
self.startx = 0
self.need_redraw = True
def clear_image(self, force=False):
if (force or self.need_clear_image) and self.image_drawn:
self.fm.image_displayer.clear(self.x, self.y, self.wid, self.hei)
self.need_clear_image = False
self.image_drawn = False
def close(self):
if self.image:
self.need_clear_image = True
self.clear_image()
self._close_source()
def destroy(self):
self.clear_image(force=True)
Widget.destroy(self)
def finalize(self):
self.fm.ui.win.move(self.y, self.x)
def scrollbit(self, lines):
target_scroll = self.scroll_extra + lines
max_scroll = len(self.lines) - self.hei
self.scroll_extra = max(0, min(target_scroll, max_scroll))
self.need_redraw = True
def draw(self):
if self.need_clear_image:
self.need_redraw = True
if self.old_source != self.source:
self.old_source = self.source
self.need_redraw = True
if self.old_scroll_begin != self.scroll_begin or \
self.old_startx != self.startx:
self.old_startx = self.startx
self.old_scroll_begin = self.scroll_begin
self.need_redraw = True
if self.need_redraw:
self.win.erase()
self.need_redraw_image = True
self.clear_image()
if not self.image:
scroll_pos = self.scroll_begin + self.scroll_extra
line_gen = self._generate_lines(
starty=scroll_pos, startx=self.startx)
for line, i in zip(line_gen, range(self.hei)):
self._draw_line(i, line)
self.need_redraw = False
def draw_image(self):
if self.image and self.need_redraw_image:
self.source = None
self.need_redraw_image = False
try:
self.fm.image_displayer.draw(self.image, self.x, self.y,
self.wid, self.hei)
except ImgDisplayUnsupportedException as ex:
self.fm.settings.preview_images = False
self.fm.notify(ex, bad=True)
except Exception as ex: # pylint: disable=broad-except
self.fm.notify(ex, bad=True)
else:
self.image_drawn = True
def _draw_line(self, i, line):
if self.markup is None:
self.addstr(i, 0, line)
elif self.markup == 'ansi':
try:
self.win.move(i, 0)
except curses.error:
pass
else:
for chunk in ansi.text_with_fg_bg_attr(line):
if isinstance(chunk, tuple):
self.set_fg_bg_attr(*chunk)
else:
self.addstr(chunk)
def move(self, narg=None, **kw):
direction = Direction(kw)
if direction.horizontal():
self.startx = direction.move(
direction=direction.right(),
override=narg,
maximum=self.max_width,
current=self.startx,
pagesize=self.wid,
offset=-self.wid + 1)
if direction.vertical():
movement = {
"direction": direction.down(),
"override": narg,
"current": self.scroll_begin,
"pagesize": self.hei,
"offset": -self.hei + 1,
}
if self.source_is_stream:
# For streams, we first pretend that the content ends much later,
# in case there are still unread lines.
desired_position = direction.move(
maximum=len(self.lines) + 9999,
**movement)
# Then, read the new lines as needed to produce a more accurate
# maximum for the movement:
self._get_line(desired_position + self.hei)
self.scroll_begin = direction.move(
maximum=len(self.lines),
**movement)
def press(self, key):
self.fm.ui.keymaps.use_keymap('pager')
self.fm.ui.press(key)
def set_image(self, image):
if self.image:
self.need_clear_image = True
self.image = image
self._close_source()
self.source = None
self.source_is_stream = False
def set_source(self, source, strip=False):
if self.image:
self.image = None
self.need_clear_image = True
self._close_source()
self.max_width = 0
if isinstance(source, str):
self.source_is_stream = False
self.lines = source.splitlines()
if self.lines:
self.max_width = max(len(line) for line in self.lines)
elif hasattr(source, '__getitem__'):
self.source_is_stream = False
self.lines = source
if self.lines:
self.max_width = max(len(line) for line in source)
elif hasattr(source, 'readline'):
self.source_is_stream = True
self.lines = []
else:
self.source = None
self.source_is_stream = False
return False
self.markup = 'ansi'
if not self.source_is_stream and strip:
self.lines = [line.strip() for line in self.lines]
self.source = source
return True
def click(self, event):
n = 1 if event.ctrl() else 3
direction = event.mouse_wheel_direction()
if direction:
self.move(down=direction * n)
return True
def _get_line(self, n, attempt_to_read=True):
assert isinstance(n, int), n
try:
return self.lines[n]
except (KeyError, IndexError):
if attempt_to_read and self.source_is_stream:
try:
for line in self.source:
if len(line) > self.max_width:
self.max_width = len(line)
self.lines.append(line)
if len(self.lines) > n:
break
except (UnicodeError, IOError):
pass
return self._get_line(n, attempt_to_read=False)
return ""
def _generate_lines(self, starty, startx):
i = starty
if not self.source:
return
while True:
try:
line = self._get_line(i).expandtabs(4)
for part in ((0,) if not
self.fm.settings.wrap_plaintext_previews else
range(max(1, ((len(line) - 1) // self.wid) + 1))):
shift = part * self.wid
if self.markup == 'ansi':
line_bit = (ansi.char_slice(line, startx + shift,
self.wid + shift)
+ ansi.reset)
else:
line_bit = line[startx + shift:self.wid + startx
+ shift]
yield line_bit.rstrip().replace('\r\n', '\n')
except IndexError:
return
i += 1
| 8,886 | Python | .py | 227 | 26.321586 | 81 | 0.529807 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
713 | view_miller.py | ranger_ranger/ranger/gui/widgets/view_miller.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""ViewMiller arranges the view in miller columns"""
from __future__ import (absolute_import, division, print_function)
import curses
from ranger.container import settings
from ranger.gui.widgets.view_base import ViewBase
from .browsercolumn import BrowserColumn
from .pager import Pager
from ..displayable import DisplayableContainer
class ViewMiller(ViewBase): # pylint: disable=too-many-ancestors,too-many-instance-attributes
ratios = None
preview = True
is_collapsed = False
stretch_ratios = None
old_collapse = False
def __init__(self, win):
ViewBase.__init__(self, win)
self.preview = True
self.columns = []
self.rebuild()
for option in ('preview_directories', 'preview_files'):
self.settings.signal_bind('setopt.' + option,
self._request_clear_if_has_borders, weak=True)
self.settings.signal_bind('setopt.column_ratios', self.request_clear)
self.settings.signal_bind('setopt.column_ratios', self.rebuild,
priority=settings.SIGNAL_PRIORITY_AFTER_SYNC)
self.old_draw_borders = self.settings.draw_borders
def rebuild(self):
for child in self.container:
if isinstance(child, BrowserColumn):
self.remove_child(child)
child.destroy()
self.pager = Pager(self.win, embedded=True)
self.pager.visible = False
self.add_child(self.pager)
ratios = self.settings.column_ratios
for column in self.columns:
column.destroy()
self.remove_child(column)
self.columns = []
ratios_sum = sum(ratios)
self.ratios = tuple((x / ratios_sum) for x in ratios)
last = 0.1 if self.settings.padding_right else 0
if len(self.ratios) >= 2:
self.stretch_ratios = self.ratios[:-2] + \
((self.ratios[-2] + self.ratios[-1] * 1.0 - last),
(self.ratios[-1] * last))
offset = 1 - len(ratios)
if self.preview:
offset += 1
for level in range(len(ratios)):
column = BrowserColumn(self.win, level + offset)
self.add_child(column)
self.columns.append(column)
try:
self.main_column = self.columns[self.preview and -2 or -1]
except IndexError:
self.main_column = None
else:
self.main_column.display_infostring = True
self.main_column.main_column = True
self.resize(self.y, self.x, self.hei, self.wid)
def _request_clear_if_has_borders(self):
if self.settings.draw_borders:
self.request_clear()
def draw(self):
if self.need_clear:
self.win.erase()
self.need_redraw = True
self.need_clear = False
for tab in self.fm.tabs.values():
directory = tab.thisdir
if directory:
directory.load_content_if_outdated()
directory.use()
DisplayableContainer.draw(self)
if self.settings.draw_borders:
draw_borders = self.settings.draw_borders.lower()
if draw_borders in ['both', 'true']: # 'true' for backwards compat.
border_types = ['separators', 'outline']
else:
border_types = [draw_borders]
self._draw_borders(border_types)
if self.draw_bookmarks:
self._draw_bookmarks()
elif self.draw_hints:
self._draw_hints()
elif self.draw_info:
self._draw_info(self.draw_info)
def _draw_borders(self, border_types): # pylint: disable=too-many-branches
win = self.win
self.color('in_browser', 'border')
left_start = 0
right_end = self.wid - 1
for child in self.columns:
if not child.has_preview():
left_start = child.x + child.wid
else:
break
# Shift the rightmost vertical line to the left to create a padding,
# but only when padding_right is on, the preview column is collapsed
# and we did not open the pager to "zoom" in to the file.
if self.settings.padding_right and not self.pager.visible and self.is_collapsed:
right_end = self.columns[-1].x - 1
if right_end < left_start:
right_end = self.wid - 1
# Draw horizontal lines and the leftmost vertical line
if 'outline' in border_types:
try:
# pylint: disable=no-member
win.hline(0, left_start, curses.ACS_HLINE, right_end - left_start)
win.hline(self.hei - 1, left_start, curses.ACS_HLINE, right_end - left_start)
win.vline(1, left_start, curses.ACS_VLINE, self.hei - 2)
# pylint: enable=no-member
except curses.error:
pass
# Draw the vertical lines in the middle
if 'separators' in border_types:
for child in self.columns[:-1]:
if not child.has_preview():
continue
if child.main_column and self.pager.visible:
# If we "zoom in" with the pager, we have to
# skip the between main_column and pager.
break
x = child.x + child.wid
y = self.hei - 1
try:
# pylint: disable=no-member
win.vline(1, x, curses.ACS_VLINE, y - 1)
if 'outline' in border_types:
self.addch(0, x, curses.ACS_TTEE, 0)
self.addch(y, x, curses.ACS_BTEE, 0)
else:
self.addch(0, x, curses.ACS_VLINE, 0)
self.addch(y, x, curses.ACS_VLINE, 0)
# pylint: enable=no-member
except curses.error:
# in case it's off the boundaries
pass
if 'outline' in border_types:
# Draw the last vertical line
try:
# pylint: disable=no-member
win.vline(1, right_end, curses.ACS_VLINE, self.hei - 2)
# pylint: enable=no-member
except curses.error:
pass
if 'outline' in border_types:
# pylint: disable=no-member
self.addch(0, left_start, curses.ACS_ULCORNER)
self.addch(self.hei - 1, left_start, curses.ACS_LLCORNER)
self.addch(0, right_end, curses.ACS_URCORNER)
self.addch(self.hei - 1, right_end, curses.ACS_LRCORNER)
# pylint: enable=no-member
def _collapse(self):
# Should the last column be cut off? (Because there is no preview)
if not self.settings.collapse_preview or not self.preview \
or not self.stretch_ratios:
return False
result = not self.columns[-1].has_preview()
target = self.columns[-1].target
if not result and target and target.is_file:
if self.fm.settings.preview_script and \
self.fm.settings.use_preview_script:
try:
result = not self.fm.previews[target.realpath]['foundpreview']
except KeyError:
return self.old_collapse
self.old_collapse = result
return result
def resize(self, y, x, hei=None, wid=None):
"""Resize all the columns according to the given ratio"""
ViewBase.resize(self, y, x, hei, wid)
border_type = self.settings.draw_borders.lower()
if border_type in ['outline', 'both', 'true']:
pad = 1
else:
pad = 0
left = pad
self.is_collapsed = self._collapse()
if self.is_collapsed:
generator = enumerate(self.stretch_ratios)
else:
generator = enumerate(self.ratios)
last_i = len(self.ratios) - 1
for i, ratio in generator:
wid = int(ratio * self.wid)
cut_off = self.is_collapsed and not self.settings.padding_right
if i == last_i:
if not cut_off:
wid = int(self.wid - left + 1 - pad)
else:
self.columns[i].resize(pad, max(0, left - 1), hei - pad * 2, 1)
self.columns[i].visible = False
continue
if i == last_i - 1:
self.pager.resize(pad, left, hei - pad * 2, max(1, self.wid - left - pad))
if cut_off:
self.columns[i].resize(pad, left, hei - pad * 2, max(1, self.wid - left - pad))
continue
try:
self.columns[i].resize(pad, left, hei - pad * 2, max(1, wid - 1))
except KeyError:
pass
left += wid
def open_pager(self):
self.pager.visible = True
self.pager.focused = True
self.need_clear = True
self.pager.open()
try:
self.columns[-1].visible = False
self.columns[-2].visible = False
except IndexError:
pass
def close_pager(self):
self.pager.visible = False
self.pager.focused = False
self.need_clear = True
self.pager.close()
try:
self.columns[-1].visible = True
self.columns[-2].visible = True
except IndexError:
pass
def poke(self):
ViewBase.poke(self)
# Show the preview column when it has a preview but has
# been hidden (e.g. because of padding_right = False)
if not self.columns[-1].visible and self.columns[-1].has_preview() \
and not self.pager.visible:
self.columns[-1].visible = True
if self.preview and self.is_collapsed != self._collapse():
if self.fm.settings.preview_files:
# force clearing the image when resizing preview column
self.columns[-1].clear_image(force=True)
self.resize(self.y, self.x, self.hei, self.wid)
if self.old_draw_borders != self.settings.draw_borders:
self.resize(self.y, self.x, self.hei, self.wid)
self.old_draw_borders = self.settings.draw_borders
| 10,550 | Python | .py | 242 | 31.132231 | 99 | 0.559606 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
714 | spawn.py | ranger_ranger/ranger/ext/spawn.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from io import open
from os import devnull
from subprocess import PIPE, CalledProcessError
from ranger.ext.popen23 import Popen23
ENCODING = 'utf-8'
def check_output(popenargs, **kwargs):
"""Runs a program, waits for its termination and returns its output
This function is functionally identical to python 2.7's subprocess.check_output,
but is favored due to python 2.6 compatibility.
Will be run through a shell if `popenargs` is a string, otherwise the command
is executed directly.
The keyword argument `decode` determines if the output shall be decoded
with the encoding UTF-8.
Further keyword arguments are passed to Popen.
"""
do_decode = kwargs.pop('decode', True)
kwargs.setdefault('stdout', PIPE)
kwargs.setdefault('shell', isinstance(popenargs, str))
if 'stderr' in kwargs:
with Popen23(popenargs, **kwargs) as process:
stdout, _ = process.communicate()
else:
with open(devnull, mode='w', encoding="utf-8") as fd_devnull:
with Popen23(popenargs, stderr=fd_devnull, **kwargs) as process:
stdout, _ = process.communicate()
if process.returncode != 0:
error = CalledProcessError(process.returncode, popenargs)
error.output = stdout
raise error
if do_decode and stdout is not None:
stdout = stdout.decode(ENCODING)
return stdout
def spawn(*popenargs, **kwargs):
"""Runs a program, waits for its termination and returns its stdout
This function is similar to python 2.7's subprocess.check_output,
but is favored due to python 2.6 compatibility.
The arguments may be:
spawn(string)
spawn(command, arg1, arg2...)
spawn([command, arg1, arg2])
Will be run through a shell if `popenargs` is a string, otherwise the command
is executed directly.
The keyword argument `decode` determines if the output shall be decoded
with the encoding UTF-8.
Further keyword arguments are passed to Popen.
"""
if len(popenargs) == 1:
return check_output(popenargs[0], **kwargs)
return check_output(list(popenargs), **kwargs)
| 2,357 | Python | .py | 52 | 39.346154 | 84 | 0.708151 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
715 | signals.py | ranger_ranger/ranger/ext/signals.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""An efficient and minimalistic signaling/hook module.
To use this in a class, subclass SignalDispatcher and call
SignalDispatcher.__init__(self) in the __init__ function. Now you can bind
functions to a signal name (string) by using signal_bind or remove it with
signal_unbind. Now whenever signal_emit is called with that signal name,
the bound functions are executed in order of priority.
This module supports weak referencing. This means that if you bind a function
which is later deleted everywhere except in this binding, Python's garbage
collector will remove it from memory. Activate it with
signal_bind(..., weak=True). The handlers for such functions are automatically
deleted when trying to call them (in signal_emit), but if they are never
called, they accumulate and should be manually deleted with
signal_garbage_collect().
>>> def test_function(signal):
... if 'display' in signal:
... print(signal.display)
... else:
... signal.stop()
>>> def temporary_function():
... print("A temporary function")
>>> sig = SignalDispatcher()
>>> # Test binding and unbinding
>>> handler1 = sig.signal_bind('test', test_function, priority=2)
>>> handler2 = sig.signal_bind('test', temporary_function, priority=1)
>>> sig.signal_emit('test', display="It works!")
It works!
A temporary function
True
>>> # Note that test_function stops the signal when there's no display keyword
>>> sig.signal_emit('test')
False
>>> sig.signal_unbind(handler1)
>>> sig.signal_emit('test')
A temporary function
True
>>> sig.signal_clear()
>>> sig.signal_emit('test')
True
>>> # Bind temporary_function with a weak reference
>>> handler = sig.signal_bind('test', temporary_function, weak=True)
>>> sig.signal_emit('test')
A temporary function
True
>>> # Delete temporary_function. Its handler is removed too, since it
>>> # was weakly referenced.
>>> del temporary_function
>>> sig.signal_emit('test')
True
"""
from __future__ import (absolute_import, division, print_function)
import weakref
from types import MethodType
class Signal(dict):
"""Signals are passed to the bound functions as an argument.
They contain the attributes "origin", which is a reference to the
signal dispatcher, and "name", the name of the signal that was emitted.
You can call signal_emit with any keyword arguments, which will be
turned into attributes of this object as well.
To delete a signal handler from inside a signal, raise a ReferenceError.
"""
stopped = False
def __init__(self, **keywords):
dict.__init__(self, keywords)
self.__dict__ = self
def stop(self):
""" Stop the propagation of the signal to the next handlers. """
self.stopped = True
class SignalHandler(object): # pylint: disable=too-few-public-methods
"""Signal Handlers contain information about a signal binding.
They are returned by signal_bind() and have to be passed to signal_unbind()
in order to remove the handler again.
You can disable a handler without removing it by setting the attribute
"active" to False.
"""
active = True
def __init__(self, signal_name, function, priority, pass_signal):
self.priority = max(0, min(1, priority))
self.signal_name = signal_name
self.function = function
self.pass_signal = pass_signal
class SignalDispatcher(object):
"""This abstract class handles the binding and emitting of signals."""
def __init__(self):
self._signals = {}
def signal_clear(self):
"""Remove all signals."""
for handler_list in self._signals.values():
for handler in handler_list:
handler.function = None
self._signals = {}
def signal_bind(self, signal_name, function, priority=0.5, weak=False, autosort=True):
"""Bind a function to the signal.
signal_name: Any string to name the signal
function: Any function with either one or zero arguments which will be
called when the signal is emitted. If it takes one argument, a
Signal object will be passed to it.
priority: Optional, any number. When signals are emitted, handlers will
be called in order of priority. (highest priority first)
weak: Use a weak reference of "function" so it can be garbage collected
properly when it's deleted.
Returns a SignalHandler which can be used to remove this binding by
passing it to signal_unbind().
"""
assert isinstance(signal_name, str)
assert hasattr(function, '__call__')
assert hasattr(function, '__code__')
assert isinstance(priority, (int, float))
assert isinstance(weak, bool)
try:
handlers = self._signals[signal_name]
except KeyError:
handlers = self._signals[signal_name] = []
nargs = function.__code__.co_argcount
if getattr(function, '__self__', None):
nargs -= 1
if weak:
function = (function.__func__, weakref.proxy(function.__self__))
elif weak:
function = weakref.proxy(function)
handler = SignalHandler(signal_name, function, priority, nargs > 0)
handlers.append(handler)
if autosort:
handlers.sort(
key=lambda handler: -handler.priority)
return handler
# TODO: Do we still use this method? Should we remove it?
def signal_force_sort(self, signal_name=None):
"""Forces a sorting of signal handlers by priority.
This is only necessary if you used signal_bind with autosort=False
after finishing to bind many signals at once.
"""
if signal_name is None:
for handlers in self._signals.values():
handlers.sort(
key=lambda handler: -handler.priority)
return None
elif signal_name in self._signals:
self._signals[signal_name].sort(
key=lambda handler: -handler.priority)
return None
return False
def signal_unbind(self, signal_handler):
"""Removes a signal binding.
This requires the SignalHandler that has been originally returned by
signal_bind().
"""
try:
handlers = self._signals[
signal_handler.signal_name]
except KeyError:
pass
else:
signal_handler.function = None
try:
handlers.remove(signal_handler)
except IndexError:
pass
def signal_garbage_collect(self):
"""Remove all handlers with deleted weak references.
Usually this is not needed; every time you emit a signal, its handlers
are automatically checked in this way. However, if you can't be sure
that a signal is ever emitted AND you keep binding weakly referenced
functions to the signal, this method should be regularly called to
avoid memory leaks in self._signals.
>>> sig = SignalDispatcher()
>>> # lambda:None is an anonymous function which has no references
>>> # so it should get deleted immediately
>>> handler = sig.signal_bind('test', lambda: None, weak=True)
>>> len(sig._signals['test'])
1
>>> # need to call garbage collect so that it's removed from the list.
>>> sig.signal_garbage_collect()
>>> len(sig._signals['test'])
0
>>> # This demonstrates that garbage collecting is not necessary
>>> # when using signal_emit().
>>> handler = sig.signal_bind('test', lambda: None, weak=True)
>>> sig.signal_emit('another_signal')
True
>>> len(sig._signals['test'])
1
>>> sig.signal_emit('test')
True
>>> len(sig._signals['test'])
0
"""
for handler_list in self._signals.values():
i = len(handler_list)
while i:
i -= 1
handler = handler_list[i]
try:
if isinstance(handler.function, tuple):
handler.function[1].__class__ # pylint: disable=pointless-statement
else:
handler.function.__class__ # pylint: disable=pointless-statement
except ReferenceError:
handler.function = None
del handler_list[i]
def signal_emit(self, signal_name, **kw):
"""Emits a signal and call every function that was bound to that signal.
You can call this method with any key words. They will be turned into
attributes of the Signal object that is passed to the functions.
If a function calls signal.stop(), no further functions will be called.
If a function raises a ReferenceError, the handler will be deleted.
Returns False if signal.stop() was called and True otherwise.
"""
assert isinstance(signal_name, str)
if signal_name not in self._signals:
return True
handlers = self._signals[signal_name]
if not handlers:
return True
signal = Signal(origin=self, name=signal_name, **kw)
# propagate
for handler in tuple(handlers):
if handler.active:
try:
if isinstance(handler.function, tuple):
fnc = MethodType(*handler.function)
else:
fnc = handler.function
if handler.pass_signal:
fnc(signal)
else:
fnc()
except ReferenceError:
handler.function = None
handlers.remove(handler)
if signal.stopped:
return False
return True
if __name__ == '__main__':
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 10,188 | Python | .py | 238 | 34.142857 | 92 | 0.62982 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
716 | direction.py | ranger_ranger/ranger/ext/direction.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""This class provides convenient methods for movement operations.
Direction objects are handled just like dicts but provide
methods like up() and down() which give you the correct value
for the vertical direction, even if only the "up" or "down" key
has been defined.
>>> d = Direction(down=5)
>>> d.down()
5
>>> d.up()
-5
>>> bool(d.horizontal())
False
"""
from __future__ import (absolute_import, division, print_function)
import math
class Direction(dict):
def __init__(self, dictionary=None, **keywords):
if dictionary is not None:
dict.__init__(self, dictionary)
else:
dict.__init__(self, keywords)
if 'to' in self:
self['down'] = self['to']
self['absolute'] = True
def copy(self):
return Direction(**self)
def _get_bool(self, first, second, fallback=None):
try:
return self[first]
except KeyError:
try:
return not self[second]
except KeyError:
return fallback
def _get_direction(self, first, second, fallback=0):
try:
return self[first]
except KeyError:
try:
return -self[second]
except KeyError:
return fallback
def up(self): # pylint: disable=invalid-name
return -Direction.down(self) # pylint: disable=invalid-unary-operand-type
def down(self):
return Direction._get_direction(self, 'down', 'up')
def right(self):
return Direction._get_direction(self, 'right', 'left')
def absolute(self):
return Direction._get_bool(self, 'absolute', 'relative')
def left(self):
return -Direction.right(self) # pylint: disable=invalid-unary-operand-type
def relative(self):
return not Direction.absolute(self)
def vertical_direction(self):
down = Direction.down(self)
return (down > 0) - (down < 0)
def horizontal_direction(self):
right = Direction.right(self)
return (right > 0) - (right < 0)
def vertical(self):
return set(self) & set(['up', 'down'])
def horizontal(self):
return set(self) & set(['left', 'right'])
def pages(self):
return 'pages' in self and self['pages']
def percentage(self):
return 'percentage' in self and self['percentage']
def cycle(self):
return self.get('cycle') in (True, 'true', 'on', 'yes')
def one_indexed(self):
return ('one_indexed' in self
and self.get('one_indexed') in (True, 'true', 'on', 'yes'))
def multiply(self, n):
for key in ('up', 'right', 'down', 'left'):
try:
self[key] *= n
except KeyError:
pass
def set(self, n):
for key in ('up', 'right', 'down', 'left'):
if key in self:
self[key] = n
def move(self, direction, override=None, minimum=0, # pylint: disable=too-many-arguments
maximum=9999, current=0, pagesize=1, offset=0):
"""Calculates the new position in a given boundary.
Example:
>>> d = Direction(pages=True)
>>> d.move(direction=3)
3
>>> d.move(direction=3, current=2)
5
>>> d.move(direction=3, pagesize=5)
15
>>> # Note: we start to count at zero.
>>> d.move(direction=3, pagesize=5, maximum=10)
9
>>> d.move(direction=9, override=2)
18
"""
pos = direction
if override is not None:
if self.absolute():
if self.one_indexed():
pos = override - 1
else:
pos = override
else:
pos *= override
if self.pages():
pos *= pagesize
elif self.percentage():
pos *= maximum / 100
if self.absolute():
if pos < minimum:
pos += maximum
else:
pos += current
if self.cycle():
cycles, pos = divmod(pos, (maximum + offset - minimum))
self['_move_cycles'] = int(cycles)
ret = minimum + pos
else:
ret = max(min(pos, maximum + offset - 1), minimum)
# Round towards the direction we're moving from.
# From the UI point of view, round down. See: #912.
if direction < 0:
ret = int(math.ceil(ret))
else:
ret = int(ret)
return ret
def move_cycles(self):
return self.get('_move_cycles', 0)
def select(self, lst, current, pagesize, override=None, offset=1):
dest = self.move(direction=self.down(), override=override,
current=current, pagesize=pagesize, minimum=0, maximum=len(lst) + 1)
selection = lst[min(current, dest):max(current, dest) + offset]
return dest + offset - 1, selection
if __name__ == '__main__':
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 5,186 | Python | .py | 144 | 26.875 | 93 | 0.564896 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
717 | popen23.py | ranger_ranger/ranger/ext/popen23.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import absolute_import
from contextlib import contextmanager
from subprocess import Popen
try:
from ranger import PY3
except ImportError:
from sys import version_info
PY3 = version_info[0] >= 3
if PY3:
# pylint: disable=ungrouped-imports,unused-import
from subprocess import DEVNULL
else:
import os
# pylint: disable=consider-using-with
DEVNULL = open(os.devnull, "wb")
# COMPAT: Python 2 (and Python <=3.2) subprocess.Popen objects aren't
# context managers. We don't care about early Python 3 but we do want
# to wrap Python 2's Popen. There's no harm in always using this Popen
# but it is only necessary when used with with-statements. This can be
# removed once we ditch Python 2 support.
@contextmanager
def Popen23(*args, **kwargs): # pylint: disable=invalid-name
if PY3:
yield Popen(*args, **kwargs)
return
else:
popen2 = Popen(*args, **kwargs)
try:
yield popen2
finally:
# From Lib/subprocess.py Popen.__exit__:
if popen2.stdout:
popen2.stdout.close()
if popen2.stderr:
popen2.stderr.close()
try: # Flushing a BufferedWriter may raise an error
if popen2.stdin:
popen2.stdin.close()
finally:
# Wait for the process to terminate, to avoid zombies.
popen2.wait()
| 1,545 | Python | .py | 43 | 30.209302 | 78 | 0.664883 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
718 | shutil_generatorized.py | ranger_ranger/ranger/ext/shutil_generatorized.py | # This file was taken from the python 2.7.13 standard library and has been
# slightly modified to do a "yield" after every 16KB of copying
from __future__ import (absolute_import, division, print_function)
import os
import stat
import sys
from shutil import (_samefile, rmtree, _basename, _destinsrc, Error, SpecialFileError)
from ranger.ext.safe_path import get_safe_path
__all__ = ["copyfileobj", "copyfileobj_range", "copyfile", "copystat", "copy2", "BLOCK_SIZE",
"copytree", "move", "rmtree", "Error", "SpecialFileError"]
BLOCK_SIZE = 16 * 1024
if sys.version_info < (3, 3):
def copystat(src, dst):
"""Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
st = os.stat(src) # pylint: disable=invalid-name
mode = stat.S_IMODE(st.st_mode)
if hasattr(os, 'utime'):
try:
os.utime(dst, (st.st_atime, st.st_mtime))
except OSError:
pass
if hasattr(os, 'chmod'):
try:
os.chmod(dst, mode)
except OSError:
pass
if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
try:
os.chflags(dst, st.st_flags) # pylint: disable=no-member
except OSError:
pass
else:
from shutil import _copyxattr # pylint: disable=no-name-in-module
def copystat(src, dst, follow_symlinks=True):
"""Copy all stat info (mode bits, atime, mtime, flags) from src to dst.
If the optional flag `follow_symlinks` is not set, symlinks aren't followed if and
only if both `src` and `dst` are symlinks.
"""
def _nop(*args, **kwargs): # pylint: disable=unused-argument
pass
# follow symlinks (aka don't not follow symlinks)
follow = os.path.exists(src) and (
follow_symlinks or not (os.path.islink(src) and os.path.islink(dst))
)
if follow:
# use the real function if it exists
def lookup(name):
return getattr(os, name, _nop)
else:
# use the real function only if it exists
# *and* it supports follow_symlinks
def lookup(name):
fn = getattr(os, name, _nop) # pylint: disable=invalid-name
if fn in os.supports_follow_symlinks: # pylint: disable=no-member
return fn
return _nop
st = lookup("stat")(src, follow_symlinks=follow) # pylint: disable=invalid-name
mode = stat.S_IMODE(st.st_mode)
try:
lookup("utime")(dst, ns=(st.st_atime_ns, st.st_mtime_ns),
follow_symlinks=follow)
except OSError:
pass
try:
lookup("chmod")(dst, mode, follow_symlinks=follow)
except NotImplementedError:
# if we got a NotImplementedError, it's because
# * follow_symlinks=False,
# * lchown() is unavailable, and
# * either
# * fchownat() is unavailable or
# * fchownat() doesn't implement AT_SYMLINK_NOFOLLOW.
# (it returned ENOSUP.)
# therefore we're out of options--we simply cannot chown the
# symlink. give up, suppress the error.
# (which is what shutil always did in this circumstance.)
pass
except OSError:
pass
if hasattr(st, 'st_flags'):
try:
lookup("chflags")(dst, st.st_flags, follow_symlinks=follow)
except OSError:
pass
try:
_copyxattr(src, dst, follow_symlinks=follow)
except OSError:
pass
def copyfileobj(fsrc, fdst, length=BLOCK_SIZE):
"""copy data from file-like object fsrc to file-like object fdst"""
done = 0
while 1:
buf = fsrc.read(length)
if not buf:
break
fdst.write(buf)
done += len(buf)
yield done
try:
_copy = os.copy_file_range
def copyfileobj_range(fsrc, fdst, length=BLOCK_SIZE):
"""copy data from fsrc to fdst with copy_file_range to enable CoW"""
src_fd = fsrc.fileno()
dst_fd = fdst.fileno()
done = 0
while 1:
# copy_file_range returns number of bytes read, or -1 if there was
# an error
read = _copy(src_fd, dst_fd, length)
if read == 0:
break
elif read == -1:
raise OSError
done += read
yield done
except AttributeError:
pass
def copyfile(src, dst):
"""Copy data from src to dst"""
if _samefile(src, dst):
raise Error("`%s` and `%s` are the same file" % (src, dst))
for fn in [src, dst]: # pylint: disable=invalid-name
try:
st = os.stat(fn) # pylint: disable=invalid-name
except OSError:
# File most likely does not exist
pass
else:
# XXX What about other special files? (sockets, devices...)
if stat.S_ISFIFO(st.st_mode):
raise SpecialFileError("`%s` is a named pipe" % fn)
with open(src, 'rb') as fsrc:
with open(dst, 'wb') as fdst:
try:
for done in copyfileobj_range(fsrc, fdst):
yield done
except OSError:
# Return to start of files first, then use old method
fsrc.seek(0, 0)
fdst.seek(0, 0)
except NameError:
pass # Just fall back if there's no copy_file_range
for done in copyfileobj(fsrc, fdst):
yield done
def copy2(src, dst, overwrite=False, symlinks=False, make_safe_path=get_safe_path):
"""Copy data and all stat info ("cp -p src dst").
The destination may be a directory.
"""
if os.path.isdir(dst):
dst = os.path.join(dst, os.path.basename(src))
if not overwrite:
dst = make_safe_path(dst)
if symlinks and os.path.islink(src):
linkto = os.readlink(src)
if overwrite and os.path.lexists(dst):
os.unlink(dst)
os.symlink(linkto, dst)
else:
for done in copyfile(src, dst):
yield done
copystat(src, dst)
def copytree(src, dst, # pylint: disable=too-many-locals,too-many-branches
symlinks=False, ignore=None, overwrite=False, make_safe_path=get_safe_path):
"""Recursively copy a directory tree using copy2().
The destination directory must not already exist.
If exception(s) occur, an Error is raised with a list of reasons.
If the optional symlinks flag is true, symbolic links in the
source tree result in symbolic links in the destination tree; if
it is false, the contents of the files pointed to by symbolic
links are copied.
The optional ignore argument is a callable. If given, it
is called with the `src` parameter, which is the directory
being visited by copytree(), and `names` which is the list of
`src` contents, as returned by os.listdir():
callable(src, names) -> ignored_names
Since copytree() is called recursively, the callable will be
called once for each directory that is copied. It returns a
list of names relative to the `src` directory that should
not be copied.
XXX Consider this example code rather than the ultimate tool.
"""
names = os.listdir(src)
if ignore is not None:
ignored_names = ignore(src, names)
else:
ignored_names = set()
try:
os.makedirs(dst)
except OSError:
if not overwrite:
dst = make_safe_path(dst)
os.makedirs(dst)
errors = []
done = 0
for name in names:
if name in ignored_names:
continue
srcname = os.path.join(src, name)
dstname = os.path.join(dst, name)
try:
if symlinks and os.path.islink(srcname):
linkto = os.readlink(srcname)
if overwrite and os.path.lexists(dstname):
os.unlink(dstname)
os.symlink(linkto, dstname)
copystat(srcname, dstname)
elif os.path.isdir(srcname):
n = 0
for n in copytree(srcname, dstname, symlinks, ignore, overwrite,
make_safe_path):
yield done + n
done += n
else:
# Will raise a SpecialFileError for unsupported file types
n = 0
for n in copy2(srcname, dstname, overwrite=overwrite, symlinks=symlinks,
make_safe_path=make_safe_path):
yield done + n
done += n
# catch the Error from the recursive copytree so that we can
# continue with other files
except Error as err:
errors.extend(err.args[0])
except EnvironmentError as why:
errors.append((srcname, dstname, str(why)))
try:
copystat(src, dst)
except OSError as why:
errors.append((src, dst, str(why)))
if errors:
raise Error(errors)
def move(src, dst, overwrite=False, make_safe_path=get_safe_path):
"""Recursively move a file or directory to another location. This is
similar to the Unix "mv" command.
If the destination is a directory or a symlink to a directory, the source
is moved inside the directory. The destination path must not already
exist.
If the destination already exists but is not a directory, it may be
overwritten depending on os.rename() semantics.
If the destination is on our current filesystem, then rename() is used.
Otherwise, src is copied to the destination and then removed.
A lot more could be done here... A look at a mv.c shows a lot of
the issues this implementation glosses over.
"""
real_dst = dst
if os.path.isdir(dst):
if _samefile(src, dst):
# We might be on a case insensitive filesystem,
# perform the rename anyway.
os.rename(src, dst)
return
real_dst = os.path.join(dst, _basename(src))
if not overwrite:
real_dst = make_safe_path(real_dst)
try:
os.rename(src, real_dst)
except OSError:
if os.path.isdir(src):
if _destinsrc(src, dst):
raise Error("Cannot move a directory '%s' into itself '%s'." % (src, dst))
for done in copytree(src, real_dst, symlinks=True, overwrite=overwrite,
make_safe_path=make_safe_path):
yield done
rmtree(src)
else:
for done in copy2(src, real_dst, symlinks=True, overwrite=overwrite,
make_safe_path=make_safe_path):
yield done
os.unlink(src)
| 10,991 | Python | .py | 269 | 30.501859 | 93 | 0.583466 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
719 | popen_forked.py | ranger_ranger/ranger/ext/popen_forked.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import os
from io import open
from subprocess import Popen
def Popen_forked(*args, **kwargs): # pylint: disable=invalid-name
"""Forks process and runs Popen with the given args and kwargs.
Returns True if forking succeeded, otherwise False.
"""
try:
pid = os.fork()
except OSError:
return False
if pid == 0:
os.setsid()
with open(os.devnull, 'r', encoding="utf-8") as null_r, open(
os.devnull, 'w', encoding="utf-8"
) as null_w:
kwargs['stdin'] = null_r
kwargs['stdout'] = kwargs['stderr'] = null_w
Popen(*args, **kwargs) # pylint: disable=consider-using-with
os._exit(0) # pylint: disable=protected-access
else:
os.wait()
return True
| 969 | Python | .py | 26 | 30.846154 | 73 | 0.635394 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
720 | hash.py | ranger_ranger/ranger/ext/hash.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from os import listdir
from os.path import getsize, isdir
from hashlib import sha256
# pylint: disable=invalid-name
def hash_chunks(filepath, h=None):
if not h:
h = sha256()
if isdir(filepath):
h.update(filepath)
yield h.hexdigest()
for fp in listdir(filepath):
for fp_chunk in hash_chunks(fp, h=h):
yield fp_chunk
elif getsize(filepath) == 0:
yield h.hexdigest()
else:
with open(filepath, 'rb') as f:
# Read the file in ~64KiB chunks (multiple of sha256's block
# size that works well enough with HDDs and SSDs)
for chunk in iter(lambda: f.read(h.block_size * 1024), b''):
h.update(chunk)
yield h.hexdigest()
| 965 | Python | .py | 25 | 31 | 72 | 0.632086 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
721 | curses_interrupt_handler.py | ranger_ranger/ranger/ext/curses_interrupt_handler.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Interrupt Signal handler for curses
This module can catch interrupt signals which would otherwise
rise a KeyboardInterrupt exception and handle it by pushing
a Ctrl+C (ASCII value 3) to the curses getch stack.
"""
from __future__ import (absolute_import, division, print_function)
import curses
import signal
_do_catch_interrupt = True # pylint: disable=invalid-name
def catch_interrupt(boolean=True):
"""Should interrupts be caught and simulate a ^C press in curses?"""
global _do_catch_interrupt # pylint: disable=global-statement,invalid-name
old_value = _do_catch_interrupt
_do_catch_interrupt = bool(boolean)
return old_value
# The handler which will be used in signal.signal()
def _interrupt_handler(signum, frame):
# if a keyboard-interrupt occurs...
if _do_catch_interrupt:
# push a Ctrl+C (ascii value 3) to the curses getch stack
curses.ungetch(3)
else:
# use the default handler
signal.default_int_handler(signum, frame)
def install_interrupt_handler():
"""Install the custom interrupt_handler"""
signal.signal(signal.SIGINT, _interrupt_handler)
def restore_interrupt_handler():
"""Restore the default_int_handler"""
signal.signal(signal.SIGINT, signal.default_int_handler)
| 1,407 | Python | .py | 32 | 40.03125 | 79 | 0.743571 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
722 | which.py | ranger_ranger/ranger/ext/which.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import shutil
from subprocess import check_output, CalledProcessError
from ranger import PY3
def which(cmd):
if PY3:
return shutil.which(cmd)
try:
return check_output(["command", "-v", cmd])
except CalledProcessError:
return None
| 461 | Python | .py | 13 | 31.307692 | 66 | 0.72912 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
723 | mount_path.py | ranger_ranger/ranger/ext/mount_path.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from os.path import realpath, abspath, dirname, ismount
def mount_path(path):
"""Get the mount root of a directory"""
path = abspath(realpath(path))
while path != '/':
if ismount(path):
return path
path = dirname(path)
return '/'
| 468 | Python | .py | 12 | 34 | 66 | 0.676991 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
724 | keybinding_parser.py | ranger_ranger/ranger/ext/keybinding_parser.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import sys
import copy
import curses.ascii
from ranger import PY3
digits = set(range(ord('0'), ord('9') + 1)) # pylint: disable=invalid-name
# Arbitrary numbers which are not used with curses.KEY_XYZ
ANYKEY, PASSIVE_ACTION, ALT_KEY, QUANT_KEY = range(9001, 9005)
special_keys = { # pylint: disable=invalid-name
'bs': curses.KEY_BACKSPACE,
'backspace': curses.KEY_BACKSPACE,
'backspace2': curses.ascii.DEL,
'delete': curses.KEY_DC,
's-delete': curses.KEY_SDC,
'insert': curses.KEY_IC,
'cr': ord("\n"),
'enter': ord("\n"),
'return': ord("\n"),
'space': ord(" "),
'esc': curses.ascii.ESC,
'escape': curses.ascii.ESC,
'down': curses.KEY_DOWN,
'up': curses.KEY_UP,
'left': curses.KEY_LEFT,
'right': curses.KEY_RIGHT,
'pagedown': curses.KEY_NPAGE,
'pageup': curses.KEY_PPAGE,
'home': curses.KEY_HOME,
'end': curses.KEY_END,
'tab': ord('\t'),
's-tab': curses.KEY_BTAB,
'lt': ord('<'),
'gt': ord('>'),
}
very_special_keys = { # pylint: disable=invalid-name
'any': ANYKEY,
'alt': ALT_KEY,
'bg': PASSIVE_ACTION,
'allow_quantifiers': QUANT_KEY,
}
def special_keys_init():
for key, val in tuple(special_keys.items()):
special_keys['a-' + key] = (ALT_KEY, val)
for char in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_!{}':
special_keys['a-' + char] = (ALT_KEY, ord(char))
for char in 'abcdefghijklmnopqrstuvwxyz_':
special_keys['c-' + char] = ord(char) - 96
special_keys['c-space'] = 0
for n in range(64):
special_keys['f' + str(n)] = curses.KEY_F0 + n
special_keys_init()
special_keys.update(very_special_keys)
del very_special_keys
reversed_special_keys = dict( # pylint: disable=invalid-name
(v, k) for k, v in special_keys.items())
def parse_keybinding(obj): # pylint: disable=too-many-branches
"""Translate a keybinding to a sequence of integers
>>> tuple(parse_keybinding("lol<CR>"))
(108, 111, 108, 10)
>>> out = tuple(parse_keybinding("x<A-Left>"))
>>> out # it's kind of dumb that you can't test for constants...
(120, 9003, 260)
>>> out[0] == ord('x')
True
>>> out[1] == ALT_KEY
True
>>> out[2] == curses.KEY_LEFT
True
"""
assert isinstance(obj, (tuple, int, str))
if isinstance(obj, tuple):
for char in obj:
yield char
elif isinstance(obj, int):
yield obj
elif isinstance(obj, str): # pylint: disable=too-many-nested-blocks
in_brackets = False
bracket_content = []
for char in obj:
if in_brackets:
if char == '>':
in_brackets = False
string = ''.join(bracket_content).lower()
try:
keys = special_keys[string]
for key in keys:
yield key
except KeyError:
if string.isdigit():
yield int(string)
else:
yield ord('<')
for bracket_char in bracket_content:
yield ord(bracket_char)
yield ord('>')
except TypeError:
yield keys # it was no tuple, just an int
else:
bracket_content.append(char)
else:
if char == '<':
in_brackets = True
bracket_content = []
else:
yield ord(char)
if in_brackets:
yield ord('<')
for char in bracket_content:
yield ord(char)
def construct_keybinding(iterable):
"""Does the reverse of parse_keybinding"""
return ''.join(key_to_string(c) for c in iterable)
def key_to_string(key):
if key in range(33, 127):
return chr(key)
if key in reversed_special_keys:
return "<%s>" % reversed_special_keys[key]
return "<%s>" % str(key)
def _unbind_traverse(pointer, keys, pos=0):
if keys[pos] not in pointer:
return
if len(keys) > pos + 1 and isinstance(pointer, dict):
_unbind_traverse(pointer[keys[pos]], keys, pos=pos + 1)
if not pointer[keys[pos]]:
del pointer[keys[pos]]
elif len(keys) == pos + 1:
try:
del pointer[keys[pos]]
except KeyError:
pass
try:
keys.pop()
except IndexError:
pass
class KeyMaps(dict):
def __init__(self, keybuffer=None):
dict.__init__(self)
self.keybuffer = keybuffer
self.used_keymap = None
def use_keymap(self, keymap_name):
self.keybuffer.keymap = self.get(keymap_name, {})
if self.used_keymap != keymap_name:
self.used_keymap = keymap_name
self.keybuffer.clear()
def _clean_input(self, context, keys):
try:
pointer = self[context]
except KeyError:
self[context] = pointer = {}
if PY3:
keys = keys.encode('utf-8').decode('latin-1')
return list(parse_keybinding(keys)), pointer
def bind(self, context, keys, leaf):
keys, pointer = self._clean_input(context, keys)
if not keys:
return
last_key = keys[-1]
for key in keys[:-1]:
try:
if isinstance(pointer[key], dict):
pointer = pointer[key]
else:
pointer[key] = pointer = {}
except KeyError:
pointer[key] = pointer = {}
pointer[last_key] = leaf
def copy(self, context, source, target):
clean_source, pointer = self._clean_input(context, source)
if not source:
return
for key in clean_source:
try:
pointer = pointer[key]
except KeyError:
raise KeyError("Tried to copy the keybinding `%s',"
" but it was not found." % source)
self.bind(context, target, copy.deepcopy(pointer))
def unbind(self, context, keys):
keys, pointer = self._clean_input(context, keys)
if not keys:
return
_unbind_traverse(pointer, keys)
class KeyBuffer(object): # pylint: disable=too-many-instance-attributes
any_key = ANYKEY
passive_key = PASSIVE_ACTION
quantifier_key = QUANT_KEY
exclude_from_anykey = [27]
def __init__(self, keymap=None):
# Pylint recommends against calling __init__ explicitly and requires
# certain fields to be declared in __init__ so we set those to None.
# For some reason list fields don't have the same requirement.
self.pointer = None
self.result = None
self.quantifier = None
self.finished_parsing_quantifier = None
self.finished_parsing = None
self.parse_error = None
self.keymap = keymap
self.clear()
def clear(self):
self.keys = []
self.wildcards = []
self.pointer = self.keymap
self.result = None
self.quantifier = None
self.finished_parsing_quantifier = False
self.finished_parsing = False
self.parse_error = False
if self.keymap and self.quantifier_key in self.keymap:
if self.keymap[self.quantifier_key] == 'false':
self.finished_parsing_quantifier = True
def add(self, key):
self.keys.append(key)
self.result = None
if not self.finished_parsing_quantifier and key in digits:
if self.quantifier is None:
self.quantifier = 0
self.quantifier = self.quantifier * 10 + key - 48 # (48 = ord(0))
else:
self.finished_parsing_quantifier = True
moved = True
if key in self.pointer:
self.pointer = self.pointer[key]
elif self.any_key in self.pointer and \
key not in self.exclude_from_anykey:
self.wildcards.append(key)
self.pointer = self.pointer[self.any_key]
else:
moved = False
if moved:
if isinstance(self.pointer, dict):
if self.passive_key in self.pointer:
self.result = self.pointer[self.passive_key]
else:
self.result = self.pointer
self.finished_parsing = True
else:
self.finished_parsing = True
self.parse_error = True
def __str__(self):
return "".join(key_to_string(c) for c in self.keys)
if __name__ == '__main__':
import doctest
sys.exit(doctest.testmod()[0])
| 9,091 | Python | .py | 246 | 26.943089 | 85 | 0.558018 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
725 | abc.py | ranger_ranger/ranger/ext/abc.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import absolute_import
from abc import ABCMeta
# A compat wrapper for the older Python versions.
try:
from abc import ABC # pylint: disable=ungrouped-imports,unused-import
except ImportError:
class ABC(object): # pylint: disable=too-few-public-methods
__metaclass__ = ABCMeta
| 448 | Python | .py | 10 | 41.8 | 79 | 0.735023 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
726 | widestring.py | ranger_ranger/ranger/ext/widestring.py | # -*- encoding: utf-8 -*-
# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import sys
from unicodedata import east_asian_width
from ranger import PY3
ASCIIONLY = set(chr(c) for c in range(1, 128))
NARROW = 1
WIDE = 2
WIDE_SYMBOLS = set('WF')
def uwid(string):
"""Return the width of a string"""
if not PY3:
string = string.decode('utf-8', 'ignore')
return sum(utf_char_width(c) for c in string)
def utf_char_width(string):
"""Return the width of a single character"""
if east_asian_width(string) in WIDE_SYMBOLS:
return WIDE
return NARROW
def string_to_charlist(string):
"""Return a list of characters with extra empty strings after wide chars"""
if not set(string) - ASCIIONLY:
return list(string)
result = []
if PY3:
for char in string:
result.append(char)
if east_asian_width(char) in WIDE_SYMBOLS:
result.append('')
else:
try:
# This raised a "UnicodeEncodeError: 'ascii' codec can't encode
# character u'\xe4' in position 10: ordinal not in range(128)"
# for me once. I thought errors='ignore' means IGNORE THE DAMN
# ERRORS but apparently it doesn't.
string = string.decode('utf-8', 'ignore')
except UnicodeEncodeError:
return []
for char in string:
result.append(char.encode('utf-8'))
if east_asian_width(char) in WIDE_SYMBOLS:
result.append('')
return result
class WideString(object): # pylint: disable=too-few-public-methods
def __init__(self, string, chars=None):
try:
self.string = str(string)
except UnicodeEncodeError:
# Here I assume that string is a "unicode" object, because why else
# would str(string) raise a UnicodeEncodeError?
self.string = string.encode('latin-1', 'ignore')
if chars is None:
self.chars = string_to_charlist(string)
else:
self.chars = chars
def __add__(self, string):
"""
>>> (WideString("a") + WideString("b")).string
'ab'
>>> (WideString("a") + WideString("b")).chars
['a', 'b']
>>> (WideString("afd") + "bc").chars
['a', 'f', 'd', 'b', 'c']
"""
if isinstance(string, str):
return WideString(self.string + string)
elif isinstance(string, WideString):
return WideString(self.string + string.string, self.chars + string.chars)
return None
def __radd__(self, string):
"""
>>> ("bc" + WideString("afd")).chars
['b', 'c', 'a', 'f', 'd']
"""
if isinstance(string, str):
return WideString(string + self.string)
elif isinstance(string, WideString):
return WideString(string.string + self.string, string.chars + self.chars)
return None
def __str__(self):
return self.string
def __repr__(self):
return '<' + self.__class__.__name__ + " '" + self.string + "'>"
def __getslice__(self, start, stop):
"""
>>> WideString("asdf")[1:3]
<WideString 'sd'>
>>> WideString("asdf")[1:-100]
<WideString ''>
>>> WideString("モヒカン")[2:4]
<WideString 'ヒ'>
>>> WideString("モヒカン")[2:5]
<WideString 'ヒ '>
>>> WideString("モabカン")[2:5]
<WideString 'ab '>
>>> WideString("モヒカン")[1:5]
<WideString ' ヒ '>
>>> WideString("モヒカン")[:]
<WideString 'モヒカン'>
>>> WideString("aモ")[0:3]
<WideString 'aモ'>
>>> WideString("aモ")[0:2]
<WideString 'a '>
>>> WideString("aモ")[0:1]
<WideString 'a'>
"""
if stop is None or stop > len(self.chars):
stop = len(self.chars)
if stop < 0:
stop = len(self.chars) + stop
if stop < 0:
return WideString("")
if start is None or start < 0:
start = 0
if stop < len(self.chars) and self.chars[stop] == '':
if self.chars[start] == '':
return WideString(' ' + ''.join(self.chars[start:stop - 1]) + ' ')
return WideString(''.join(self.chars[start:stop - 1]) + ' ')
if self.chars[start] == '':
return WideString(' ' + ''.join(self.chars[start:stop - 1]))
return WideString(''.join(self.chars[start:stop]))
def __getitem__(self, i):
"""
>>> WideString("asdf")[2]
<WideString 'd'>
>>> WideString("……")[0]
<WideString '…'>
>>> WideString("……")[1]
<WideString '…'>
"""
if isinstance(i, slice):
return self.__getslice__(i.start, i.stop)
return self.__getslice__(i, i + 1)
def __len__(self):
"""
>>> len(WideString("poo"))
3
>>> len(WideString("モヒカン"))
8
"""
return len(self.chars)
if __name__ == '__main__':
import doctest
sys.exit(doctest.testmod()[0])
| 5,303 | Python | .py | 146 | 27.171233 | 85 | 0.543818 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
727 | accumulator.py | ranger_ranger/ranger/ext/accumulator.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from abc import abstractmethod
from ranger.ext.direction import Direction
class Accumulator(object):
def __init__(self):
self.pointer = 0
self.pointed_obj = None
def move(self, narg=None, **keywords):
direction = Direction(keywords)
lst = self.get_list()
if not lst:
return self.pointer
pointer = direction.move(
direction=direction.down(),
maximum=len(lst),
override=narg,
pagesize=self.get_height(),
current=self.pointer)
self.pointer = pointer
self.correct_pointer()
return pointer
def move_to_obj(self, arg, attr=None):
if not arg:
return None
lst = self.get_list()
if not lst:
return None
do_get_attr = isinstance(attr, str)
good = arg
if do_get_attr:
try:
good = getattr(arg, attr)
except (TypeError, AttributeError):
pass
for obj, i in zip(lst, range(len(lst))):
if do_get_attr:
try:
test = getattr(obj, attr)
except AttributeError:
continue
else:
test = obj
if test == good:
self.move(to=i)
return True
return self.move(to=self.pointer)
# XXX Is this still necessary? move() ensures correct pointer position
def correct_pointer(self):
lst = self.get_list()
if not lst:
self.pointer = 0
self.pointed_obj = None
else:
i = self.pointer
if i is None:
i = 0
if i >= len(lst):
i = len(lst) - 1
i = max(0, i)
self.pointer = i
self.pointed_obj = lst[i]
def pointer_is_synced(self):
lst = self.get_list()
try:
return lst[self.pointer] == self.pointed_obj
except (IndexError, KeyError):
return False
def sync_index(self, **kw):
self.move_to_obj(self.pointed_obj, **kw)
@abstractmethod
def get_list(self):
"""OVERRIDE THIS"""
return []
@staticmethod
def get_height():
"""OVERRIDE THIS"""
return 25
| 2,538 | Python | .py | 79 | 21.607595 | 75 | 0.533881 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
728 | safe_path.py | ranger_ranger/ranger/ext/safe_path.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import absolute_import
import os
SUFFIX = '_'
def get_safe_path(dst):
if not os.path.exists(dst):
return dst
if not dst.endswith(SUFFIX):
dst += SUFFIX
if not os.path.exists(dst):
return dst
n = 0
test_dst = dst + str(n)
while os.path.exists(test_dst):
n += 1
test_dst = dst + str(n)
return test_dst
| 520 | Python | .py | 18 | 23.388889 | 65 | 0.623742 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
729 | get_executables.py | ranger_ranger/ranger/ext/get_executables.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from os import listdir, environ, stat
import platform
import shlex
from stat import S_IXOTH, S_IFREG
from ranger.ext.iter_tools import unique
_cached_executables = None # pylint: disable=invalid-name
def get_executables():
"""Return all executable files in $PATH. Cached version."""
global _cached_executables # pylint: disable=global-statement,invalid-name
if _cached_executables is None:
_cached_executables = get_executables_uncached()
return _cached_executables
def _in_wsl():
# Check if the current environment is Microsoft WSL instead of native Linux
# WSL 2 has `WSL2` in the release string but WSL 1 does not, both contain
# `microsoft`, lower case.
return 'microsoft' in platform.release()
def get_executables_uncached(*paths):
"""Return all executable files in each of the given directories.
Looks in $PATH by default.
"""
if not paths:
try:
pathstring = environ['PATH']
except KeyError:
return ()
paths = unique(pathstring.split(':'))
executables = set()
in_wsl = _in_wsl()
for path in paths:
if in_wsl and path.startswith('/mnt/c/'):
continue
try:
content = listdir(path)
except OSError:
continue
for item in content:
abspath = path + '/' + item
try:
filestat = stat(abspath)
except OSError:
continue
if filestat.st_mode & (S_IXOTH | S_IFREG):
executables.add(item)
return executables
def get_term():
"""Get the user terminal executable name.
Either $TERMCMD, $TERM, "x-terminal-emulator" or "xterm", in this order.
"""
command = environ.get('TERMCMD', environ.get('TERM'))
if shlex.split(command)[0] not in get_executables():
command = 'x-terminal-emulator'
if command not in get_executables():
command = 'xterm'
return command
| 2,185 | Python | .py | 58 | 30.603448 | 79 | 0.64756 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
730 | cached_function.py | ranger_ranger/ranger/ext/cached_function.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
# Similar to functools.lru_cache of python3
def cached_function(fnc):
cache = {}
def inner_cached_function(*args):
try:
return cache[args]
except KeyError:
value = fnc(*args)
cache[args] = value
return value
inner_cached_function._cache = cache # pylint: disable=protected-access
return inner_cached_function
| 584 | Python | .py | 15 | 32.333333 | 76 | 0.670796 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
731 | img_display.py | ranger_ranger/ranger/ext/img_display.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# Author: Emanuel Guevel, 2013
# Author: Delisa Mason, 2015
"""Interface for drawing images into the console
This module provides functions to draw images in the terminal using supported
implementations.
"""
from __future__ import (absolute_import, division, print_function)
import base64
import curses
import errno
import fcntl
import os
import struct
import sys
import warnings
import json
import mmap
import threading
from subprocess import Popen, PIPE, check_call, CalledProcessError
from collections import defaultdict, namedtuple
import termios
from contextlib import contextmanager
import codecs
from tempfile import gettempdir, NamedTemporaryFile, TemporaryFile
from ranger import PY3
from ranger.core.shared import FileManagerAware, SettingsAware
from ranger.ext.popen23 import Popen23, DEVNULL
from ranger.ext.which import which
if which("magick"):
# Magick >= 7
MAGICK_CONVERT_CMD_BASE = ("magick",)
else:
# Magick < 7
MAGICK_CONVERT_CMD_BASE = ("convert",)
W3MIMGDISPLAY_ENV = "W3MIMGDISPLAY_PATH"
W3MIMGDISPLAY_OPTIONS = []
W3MIMGDISPLAY_PATHS = [
'/usr/lib/w3m/w3mimgdisplay',
'/usr/libexec/w3m/w3mimgdisplay',
'/usr/lib64/w3m/w3mimgdisplay',
'/usr/libexec64/w3m/w3mimgdisplay',
'/usr/local/libexec/w3m/w3mimgdisplay',
]
# Helper functions shared between the previewers (make them static methods of the base class?)
@contextmanager
def temporarily_moved_cursor(to_y, to_x):
"""Common boilerplate code to move the cursor to a drawing area. Use it as:
with temporarily_moved_cursor(dest_y, dest_x):
your_func_here()"""
curses.putp(curses.tigetstr("sc"))
move_cur(to_y, to_x)
yield
curses.putp(curses.tigetstr("rc"))
sys.stdout.flush()
# this is excised since Terminology needs to move the cursor multiple times
def move_cur(to_y, to_x):
tparm = curses.tparm(curses.tigetstr("cup"), to_y, to_x)
# on python2 stdout is already in binary mode, in python3 is accessed via buffer
bin_stdout = getattr(sys.stdout, 'buffer', sys.stdout)
bin_stdout.write(tparm)
def get_terminal_size():
farg = struct.pack("HHHH", 0, 0, 0, 0)
fd_stdout = sys.stdout.fileno()
fretint = fcntl.ioctl(fd_stdout, termios.TIOCGWINSZ, farg)
return struct.unpack("HHHH", fretint)
def get_font_dimensions():
"""
Get the height and width of a character displayed in the terminal in
pixels.
"""
rows, cols, xpixels, ypixels = get_terminal_size()
return (xpixels // cols), (ypixels // rows)
def image_fit_width(width, height, max_cols, max_rows, font_width=None, font_height=None):
if font_width is None or font_height is None:
font_width, font_height = get_font_dimensions()
max_width = font_width * max_cols
max_height = font_height * max_rows
if height > max_height:
if width > max_width:
width_scale = max_width / width
height_scale = max_height / height
min_scale = min(width_scale, height_scale)
return width * min_scale
else:
scale = max_height / height
return width * scale
elif width > max_width:
scale = max_width / width
return width * scale
else:
return width
class ImageDisplayError(Exception):
pass
class ImgDisplayUnsupportedException(Exception, SettingsAware):
def __init__(self, message=None):
if message is None:
message = (
'"{0}" does not appear to be a valid setting for'
' preview_images_method.'
).format(self.settings.preview_images_method)
super(ImgDisplayUnsupportedException, self).__init__(message)
def fallback_image_displayer():
"""Simply makes some noise when chosen. Temporary fallback behavior."""
raise ImgDisplayUnsupportedException
IMAGE_DISPLAYER_REGISTRY = defaultdict(fallback_image_displayer)
def register_image_displayer(nickname=None):
"""Register an ImageDisplayer by nickname if available."""
def decorator(image_displayer_class):
if nickname:
registry_key = nickname
else:
registry_key = image_displayer_class.__name__
IMAGE_DISPLAYER_REGISTRY[registry_key] = image_displayer_class
return image_displayer_class
return decorator
def get_image_displayer(registry_key):
image_displayer_class = IMAGE_DISPLAYER_REGISTRY[registry_key]
return image_displayer_class()
class ImageDisplayer(object):
"""Image display provider functions for drawing images in the terminal"""
working_dir = os.environ.get('XDG_RUNTIME_DIR', os.path.expanduser("~") or None)
def draw(self, path, start_x, start_y, width, height):
"""Draw an image at the given coordinates."""
def clear(self, start_x, start_y, width, height):
"""Clear a part of terminal display."""
def quit(self):
"""Cleanup and close"""
@register_image_displayer("w3m")
class W3MImageDisplayer(ImageDisplayer, FileManagerAware):
"""Implementation of ImageDisplayer using w3mimgdisplay, an utilitary
program from w3m (a text-based web browser). w3mimgdisplay can display
images either in virtual tty (using linux framebuffer) or in a Xorg session.
Does not work over ssh.
w3m need to be installed for this to work.
"""
is_initialized = False
def __init__(self):
self.binary_path = None
self.process = None
def initialize(self):
"""start w3mimgdisplay"""
self.binary_path = None
self.binary_path = self._find_w3mimgdisplay_executable() # may crash
# We cannot close the process because that stops the preview.
# pylint: disable=consider-using-with
self.process = Popen([self.binary_path] + W3MIMGDISPLAY_OPTIONS, cwd=self.working_dir,
stdin=PIPE, stdout=PIPE, universal_newlines=True)
self.is_initialized = True
@staticmethod
def _find_w3mimgdisplay_executable():
paths = [os.environ.get(W3MIMGDISPLAY_ENV, None)] + W3MIMGDISPLAY_PATHS
for path in paths:
if path is not None and os.path.exists(path):
return path
raise ImageDisplayError("No w3mimgdisplay executable found. Please set "
"the path manually by setting the %s environment variable. (see "
"man page)" % W3MIMGDISPLAY_ENV)
def _get_font_dimensions(self):
# Get the height and width of a character displayed in the terminal in
# pixels.
if self.binary_path is None:
self.binary_path = self._find_w3mimgdisplay_executable()
farg = struct.pack("HHHH", 0, 0, 0, 0)
fd_stdout = sys.stdout.fileno()
fretint = fcntl.ioctl(fd_stdout, termios.TIOCGWINSZ, farg)
rows, cols, xpixels, ypixels = struct.unpack("HHHH", fretint)
if xpixels == 0 and ypixels == 0:
with Popen23(
[self.binary_path, "-test"],
stdout=PIPE,
universal_newlines=True,
) as process:
output, _ = process.communicate()
output = output.split()
xpixels, ypixels = int(output[0]), int(output[1])
# adjust for misplacement
xpixels += 2
ypixels += 2
return (xpixels // cols), (ypixels // rows)
def draw(self, path, start_x, start_y, width, height):
if not self.is_initialized or self.process.poll() is not None:
self.initialize()
input_gen = self._generate_w3m_input(path, start_x, start_y, width,
height)
self.process.stdin.write(input_gen)
self.process.stdin.flush()
self.process.stdout.readline()
# Mitigate the issue with the horizontal black bars when
# selecting some images on some systems. 2 milliseconds seems
# enough. Adjust as necessary.
if self.fm.settings.w3m_delay > 0:
from time import sleep
sleep(self.fm.settings.w3m_delay)
# HACK workaround for w3mimgdisplay memory leak
self.quit()
self.is_initialized = False
def clear(self, start_x, start_y, width, height):
if not self.is_initialized or self.process.poll() is not None:
self.initialize()
fontw, fonth = self._get_font_dimensions()
cmd = "6;{x};{y};{w};{h}\n4;\n3;\n".format(
x=int((start_x - 0.2) * fontw),
y=start_y * fonth,
# y = int((start_y + 1) * fonth), # (for tmux top status bar)
w=int((width + 0.4) * fontw),
h=height * fonth + 1,
# h = (height - 1) * fonth + 1, # (for tmux top status bar)
)
try:
self.fm.ui.win.redrawwin()
self.process.stdin.write(cmd)
except IOError as ex:
if ex.errno == errno.EPIPE:
return
raise
self.process.stdin.flush()
self.process.stdout.readline()
def _generate_w3m_input(self, path, start_x, start_y, max_width, max_height):
"""Prepare the input string for w3mimgpreview
start_x, start_y, max_height and max_width specify the drawing area.
They are expressed in number of characters.
"""
fontw, fonth = self._get_font_dimensions()
if fontw == 0 or fonth == 0:
raise ImgDisplayUnsupportedException
max_width_pixels = max_width * fontw
max_height_pixels = max_height * fonth - 2
# (for tmux top status bar)
# max_height_pixels = (max_height - 1) * fonth - 2
# get image size
cmd = "5;{path}\n".format(path=path)
self.process.stdin.write(cmd)
self.process.stdin.flush()
output = self.process.stdout.readline().split()
if len(output) != 2:
raise ImageDisplayError('Failed to execute w3mimgdisplay', output)
width = int(output[0])
height = int(output[1])
# get the maximum image size preserving ratio
if width > max_width_pixels:
height = (height * max_width_pixels) // width
width = max_width_pixels
if height > max_height_pixels:
width = (width * max_height_pixels) // height
height = max_height_pixels
start_x = int((start_x - 0.2) * fontw) + self.fm.settings.w3m_offset
start_y = (start_y * fonth) + self.fm.settings.w3m_offset
return "0;1;{x};{y};{w};{h};;;;;{filename}\n4;\n3;\n".format(
x=start_x,
y=start_y,
# y = (start_y + 1) * fonth, # (for tmux top status bar)
w=width,
h=height,
filename=path,
)
def quit(self):
if self.is_initialized and self.process and self.process.poll() is None:
self.process.kill()
# TODO: remove FileManagerAwareness, as stuff in ranger.ext should be
# ranger-independent libraries.
@register_image_displayer("iterm2")
class ITerm2ImageDisplayer(ImageDisplayer, FileManagerAware):
"""Implementation of ImageDisplayer using iTerm2 image display support
(http://iterm2.com/images.html).
Ranger must be running in iTerm2 for this to work.
"""
def draw(self, path, start_x, start_y, width, height):
with temporarily_moved_cursor(start_y, start_x):
sys.stdout.write(self._generate_iterm2_input(path, width, height))
def clear(self, start_x, start_y, width, height):
self.fm.ui.win.redrawwin()
self.fm.ui.win.refresh()
def quit(self):
self.clear(0, 0, 0, 0)
def _generate_iterm2_input(self, path, max_cols, max_rows):
"""Prepare the image content of path for image display in iTerm2"""
image_width, image_height = self._get_image_dimensions(path)
if max_cols == 0 or max_rows == 0 or image_width == 0 or image_height == 0:
return ""
image_width = self._fit_width(
image_width, image_height, max_cols, max_rows)
content, byte_size = self._encode_image_content(path)
display_protocol = "\033"
close_protocol = "\a"
if os.environ["TERM"].startswith(("screen", "tmux")):
display_protocol += "Ptmux;\033\033"
close_protocol += "\033\\"
text = "{0}]1337;File=inline=1;preserveAspectRatio=0;size={1};width={2}px:{3}{4}\n".format(
display_protocol,
str(byte_size),
str(int(image_width)),
content,
close_protocol)
return text
def _fit_width(self, width, height, max_cols, max_rows):
font_width = self.fm.settings.iterm2_font_width
font_height = self.fm.settings.iterm2_font_height
return image_fit_width(
width, height, max_cols, max_rows, font_width, font_height
)
@staticmethod
def _encode_image_content(path):
"""Read and encode the contents of path"""
with open(path, 'rb') as fobj:
content = fobj.read()
return base64.b64encode(content).decode('utf-8'), len(content)
@staticmethod
def imghdr_what(path):
"""Replacement for the deprecated imghdr module"""
with open(path, "rb") as img_file:
header = img_file.read(32)
if header[6:10] in (b'JFIF', b'Exif'):
return 'jpeg'
elif header[:4] == b'\xff\xd8\xff\xdb':
return 'jpeg'
elif header.startswith(b'\211PNG\r\n\032\n'):
return 'png'
if header[:6] in (b'GIF87a', b'GIF89a'):
return 'gif'
else:
return None
@staticmethod
def _get_image_dimensions(path):
"""Determine image size using imghdr"""
with open(path, 'rb') as file_handle:
file_header = file_handle.read(24)
image_type = ITerm2ImageDisplayer.imghdr_what(path)
if len(file_header) != 24:
return 0, 0
if image_type == 'png':
check = struct.unpack('>i', file_header[4:8])[0]
if check != 0x0d0a1a0a:
return 0, 0
width, height = struct.unpack('>ii', file_header[16:24])
elif image_type == 'gif':
width, height = struct.unpack('<HH', file_header[6:10])
elif image_type == 'jpeg':
unreadable = OSError if PY3 else IOError
try:
file_handle.seek(0)
size = 2
ftype = 0
while not 0xc0 <= ftype <= 0xcf:
file_handle.seek(size, 1)
byte = file_handle.read(1)
while ord(byte) == 0xff:
byte = file_handle.read(1)
ftype = ord(byte)
size = struct.unpack('>H', file_handle.read(2))[0] - 2
file_handle.seek(1, 1)
height, width = struct.unpack('>HH', file_handle.read(4))
except unreadable:
height, width = 0, 0
else:
return 0, 0
return width, height
_CacheableSixelImage = namedtuple("_CacheableSixelImage", ("width", "height", "inode"))
_CachedSixelImage = namedtuple("_CachedSixelImage", ("image", "fh"))
@register_image_displayer("sixel")
class SixelImageDisplayer(ImageDisplayer, FileManagerAware):
"""Implementation of ImageDisplayer using SIXEL."""
def __init__(self):
self.win = None
self.cache = {}
self.fm.signal_bind('preview.cleared', lambda signal: self._clear_cache(signal.path))
def _clear_cache(self, path):
if os.path.exists(path):
self.cache = {
ce: cd
for ce, cd in self.cache.items()
if ce.inode != os.stat(path).st_ino
}
def _sixel_cache(self, path, width, height):
stat = os.stat(path)
cacheable = _CacheableSixelImage(width, height, stat.st_ino)
if cacheable not in self.cache:
font_width, font_height = get_font_dimensions()
fit_width = font_width * width
fit_height = font_height * height
sixel_dithering = self.fm.settings.sixel_dithering
cached = TemporaryFile("w+", prefix="ranger", suffix=path.replace(os.sep, "-"))
environ = dict(os.environ)
environ.setdefault("MAGICK_OCL_DEVICE", "true")
try:
check_call(
[
*MAGICK_CONVERT_CMD_BASE,
path + "[0]",
"-geometry",
"{0}x{1}>".format(fit_width, fit_height),
"-dither",
sixel_dithering,
"sixel:-",
],
stdout=cached,
stderr=DEVNULL,
env=environ,
)
except CalledProcessError:
raise ImageDisplayError("ImageMagick failed processing the SIXEL image")
except FileNotFoundError:
raise ImageDisplayError("SIXEL image previews require ImageMagick")
finally:
cached.flush()
if os.fstat(cached.fileno()).st_size == 0:
raise ImageDisplayError("ImageMagick produced an empty SIXEL image file")
self.cache[cacheable] = _CachedSixelImage(mmap.mmap(cached.fileno(), 0), cached)
return self.cache[cacheable].image
def draw(self, path, start_x, start_y, width, height):
if self.win is None:
self.win = self.fm.ui.win.subwin(height, width, start_y, start_x)
else:
self.win.mvwin(start_y, start_x)
self.win.resize(height, width)
with temporarily_moved_cursor(start_y, start_x):
sixel = self._sixel_cache(path, width, height)[:]
if PY3:
sys.stdout.buffer.write(sixel)
else:
sys.stdout.write(sixel)
sys.stdout.flush()
def clear(self, start_x, start_y, width, height):
if self.win is not None:
self.win.clear()
self.win.refresh()
self.win = None
self.fm.ui.win.redrawwin()
def quit(self):
self.clear(0, 0, 0, 0)
self.cache = {}
@register_image_displayer("terminology")
class TerminologyImageDisplayer(ImageDisplayer, FileManagerAware):
"""Implementation of ImageDisplayer using terminology image display support
(https://github.com/billiob/terminology).
Ranger must be running in terminology for this to work.
Doesn't work with TMUX :/
"""
def __init__(self):
self.display_protocol = "\033"
self.close_protocol = "\000"
def draw(self, path, start_x, start_y, width, height):
with temporarily_moved_cursor(start_y, start_x):
# Write intent
sys.stdout.write("%s}ic#%d;%d;%s%s" % (
self.display_protocol,
width, height,
path,
self.close_protocol))
# Write Replacement commands ('#')
for y in range(0, height):
move_cur(start_y + y, start_x)
sys.stdout.write("%s}ib%s%s%s}ie%s\n" % ( # needs a newline to work
self.display_protocol,
self.close_protocol,
"#" * width,
self.display_protocol,
self.close_protocol))
def clear(self, start_x, start_y, width, height):
self.fm.ui.win.redrawwin()
self.fm.ui.win.refresh()
def quit(self):
self.clear(0, 0, 0, 0)
@register_image_displayer("urxvt")
class URXVTImageDisplayer(ImageDisplayer, FileManagerAware):
"""Implementation of ImageDisplayer working by setting the urxvt
background image "under" the preview pane.
Ranger must be running in urxvt for this to work.
"""
def __init__(self):
self.display_protocol = "\033"
self.close_protocol = "\a"
if os.environ["TERM"].startswith(("screen", "tmux")):
self.display_protocol += "Ptmux;\033\033"
self.close_protocol += "\033\\"
self.display_protocol += "]20;"
@staticmethod
def _get_max_sizes():
"""Use the whole terminal."""
pct_width = 100
pct_height = 100
return pct_width, pct_height
@staticmethod
def _get_centered_offsets():
"""Center the image."""
pct_x = 50
pct_y = 50
return pct_x, pct_y
def _get_sizes(self):
"""Return the width and height of the preview pane in relation to the
whole terminal window.
"""
if self.fm.ui.pager.visible:
return self._get_max_sizes()
total_columns_ratio = sum(self.fm.settings.column_ratios)
preview_column_ratio = self.fm.settings.column_ratios[-1]
pct_width = int((100 * preview_column_ratio) / total_columns_ratio)
pct_height = 100 # As much as possible while preserving the aspect ratio.
return pct_width, pct_height
def _get_offsets(self):
"""Return the offsets of the image center."""
if self.fm.ui.pager.visible:
return self._get_centered_offsets()
pct_x = 100 # Right-aligned.
pct_y = 2 # TODO: Use the font size to calculate this offset.
return pct_x, pct_y
def draw(self, path, start_x, start_y, width, height):
# The coordinates in the arguments are ignored as urxvt takes
# the coordinates in a non-standard way: the position of the
# image center as a percentage of the terminal size. As a
# result all values below are in percents.
pct_x, pct_y = self._get_offsets()
pct_width, pct_height = self._get_sizes()
sys.stdout.write(
self.display_protocol
+ path
+ ";{pct_width}x{pct_height}+{pct_x}+{pct_y}:op=keep-aspect".format(
pct_width=pct_width, pct_height=pct_height, pct_x=pct_x, pct_y=pct_y
)
+ self.close_protocol
)
sys.stdout.flush()
def clear(self, start_x, start_y, width, height):
sys.stdout.write(
self.display_protocol
+ ";100x100+1000+1000"
+ self.close_protocol
)
sys.stdout.flush()
def quit(self):
self.clear(0, 0, 0, 0) # dummy assignments
@register_image_displayer("urxvt-full")
class URXVTImageFSDisplayer(URXVTImageDisplayer):
"""URXVTImageDisplayer that utilizes the whole terminal."""
def _get_sizes(self):
"""Use the whole terminal."""
return self._get_max_sizes()
def _get_offsets(self):
"""Center the image."""
return self._get_centered_offsets()
@register_image_displayer("kitty")
class KittyImageDisplayer(ImageDisplayer, FileManagerAware):
"""Implementation of ImageDisplayer for kitty (https://github.com/kovidgoyal/kitty/)
terminal. It uses the built APC to send commands and data to kitty,
which in turn renders the image. The APC takes the form
'\033_Gk=v,k=v...;bbbbbbbbbbbbbb\033\\'
| ---------- -------------- |
escape code | | escape code
| base64 encoded payload
key: value pairs as parameters
For more info please head over to :
https://github.com/kovidgoyal/kitty/blob/master/graphics-protocol.asciidoc"""
protocol_start = b'\x1b_G'
protocol_end = b'\x1b\\'
# we are going to use stdio in binary mode a lot, so due to py2 -> py3
# differences is worth to do this:
stdbout = getattr(sys.stdout, 'buffer', sys.stdout)
stdbin = getattr(sys.stdin, 'buffer', sys.stdin)
# counter for image ids on kitty's end
image_id = 0
# we need to find out the encoding for a path string, ascii won't cut it
try:
fsenc = sys.getfilesystemencoding() # returns None if standard utf-8 is used
# throws LookupError if can't find the codec, TypeError if fsenc is None
codecs.lookup(fsenc)
except (LookupError, TypeError):
fsenc = 'utf-8'
def __init__(self):
# the rest of the initializations that require reading stdio or raising exceptions
# are delayed to the first draw call, since curses
# and ranger exception handler are not online at __init__() time
self.needs_late_init = True
# to init in _late_init()
self.backend = None
self.stream = None
self.pix_row, self.pix_col = (0, 0)
self.temp_file_dir = None # Only used when streaming is not an option
def _late_init(self):
# tmux
if 'kitty' not in os.environ['TERM']:
# this doesn't seem to work, ranger freezes...
# commenting out the response check does nothing
# self.protocol_start = b'\033Ptmux;\033' + self.protocol_start
# self.protocol_end += b'\033\\'
raise ImgDisplayUnsupportedException(
'kitty previews only work in'
+ ' kitty and outside tmux. '
+ 'Make sure your TERM contains the string "kitty"')
# automatic check if we share the filesystem using a dummy file
with NamedTemporaryFile() as tmpf:
tmpf.write(bytearray([0xFF] * 3))
tmpf.flush()
for cmd in self._format_cmd_str(
{'a': 'q', 'i': 1, 'f': 24, 't': 'f', 's': 1, 'v': 1, 'S': 3},
payload=base64.standard_b64encode(tmpf.name.encode(self.fsenc))):
self.stdbout.write(cmd)
sys.stdout.flush()
resp = b''
while resp[-2:] != self.protocol_end:
resp += self.stdbin.read(1)
# set the transfer method based on the response
# if resp.find(b'OK') != -1:
if b'OK' in resp:
self.stream = False
self.temp_file_dir = os.path.join(
gettempdir(), "tty-graphics-protocol"
)
try:
os.mkdir(self.temp_file_dir)
except OSError:
# COMPAT: Python 2.7 does not define FileExistsError so we have
# to check whether the problem is the directory already being
# present. This is prone to race conditions, TOCTOU.
if not os.path.isdir(self.temp_file_dir):
raise ImgDisplayUnsupportedException(
"Could not create temporary directory for previews : {d}".format(
d=self.temp_file_dir
)
)
elif b'EBADF' in resp:
self.stream = True
else:
raise ImgDisplayUnsupportedException(
'kitty replied an unexpected response: {r}'.format(r=resp))
# get the image manipulation backend
try:
# pillow is the default since we are not going
# to spawn other processes, so it _should_ be faster
import PIL.Image
self.backend = PIL.Image
except ImportError:
raise ImageDisplayError("Image previews in kitty require PIL (pillow)")
# TODO: implement a wrapper class for Imagemagick process to
# replicate the functionality we use from im
# get dimensions of a cell in pixels
ret = fcntl.ioctl(sys.stdout, termios.TIOCGWINSZ,
struct.pack('HHHH', 0, 0, 0, 0))
n_cols, n_rows, x_px_tot, y_px_tot = struct.unpack('HHHH', ret)
self.pix_row, self.pix_col = x_px_tot // n_rows, y_px_tot // n_cols
self.needs_late_init = False
def draw(self, path, start_x, start_y, width, height):
self.image_id += 1
# dictionary to store the command arguments for kitty
# a is the display command, with T going for immediate output
# i is the id entifier for the image
cmds = {'a': 'T', 'i': self.image_id}
# sys.stderr.write('{0}-{1}@{2}x{3}\t'.format(
# start_x, start_y, width, height))
# finish initialization if it is the first call
if self.needs_late_init:
self._late_init()
with warnings.catch_warnings(record=True): # as warn:
warnings.simplefilter('ignore', self.backend.DecompressionBombWarning)
image = self.backend.open(path)
# TODO: find a way to send a message to the user that
# doesn't stop the image from displaying
# if warn:
# raise ImageDisplayError(str(warn[-1].message))
box = (width * self.pix_row, height * self.pix_col)
if image.width > box[0] or image.height > box[1]:
scale = min(box[0] / image.width, box[1] / image.height)
image = image.resize((int(scale * image.width), int(scale * image.height)),
self.backend.LANCZOS)
if image.mode not in ("RGB", "RGBA"):
image = image.convert(
"RGBA" if "transparency" in image.info else "RGB"
)
# start_x += ((box[0] - image.width) // 2) // self.pix_row
# start_y += ((box[1] - image.height) // 2) // self.pix_col
if self.stream:
# encode the whole image as base64
# TODO: implement z compression
# to possibly increase resolution in sent image
# t: transmissium medium, 'd' for embedded
# f: size of a pixel fragment (8bytes per color)
# s, v: size of the image to recompose the flattened data
# c, r: size in cells of the viewbox
cmds.update({'t': 'd', 'f': len(image.getbands()) * 8,
's': image.width, 'v': image.height, })
payload = base64.standard_b64encode(
bytearray().join(map(bytes, image.getdata())))
else:
# put the image in a temporary png file
# t: transmissium medium, 't' for temporary file (kitty will delete it for us)
# f: size of a pixel fragment (100 just mean that the file is png encoded,
# the only format except raw RGB(A) bitmap that kitty understand)
# c, r: size in cells of the viewbox
cmds.update({'t': 't', 'f': 100, })
with NamedTemporaryFile(
prefix='ranger_thumb_',
suffix='.png',
dir=self.temp_file_dir,
delete=False,
) as tmpf:
image.save(tmpf, format='png', compress_level=0)
payload = base64.standard_b64encode(tmpf.name.encode(self.fsenc))
with temporarily_moved_cursor(int(start_y), int(start_x)):
for cmd_str in self._format_cmd_str(cmds, payload=payload):
self.stdbout.write(cmd_str)
# catch kitty answer before the escape codes corrupt the console
resp = b''
while resp[-2:] != self.protocol_end:
resp += self.stdbin.read(1)
if b'OK' in resp:
return
else:
raise ImageDisplayError('kitty replied "{r}"'.format(r=resp))
def clear(self, start_x, start_y, width, height):
# let's assume that every time ranger call this
# it actually wants just to remove the previous image
# TODO: implement this using the actual x, y, since the protocol
# supports it
cmds = {'a': 'd', 'i': self.image_id}
for cmd_str in self._format_cmd_str(cmds):
self.stdbout.write(cmd_str)
self.stdbout.flush()
# kitty doesn't seem to reply on deletes, checking like we do in draw()
# will slows down scrolling with timeouts from select
self.image_id = max(0, self.image_id - 1)
self.fm.ui.win.redrawwin()
self.fm.ui.win.refresh()
def _format_cmd_str(self, cmd, payload=None, max_slice_len=2048):
central_blk = ','.join(["{k}={v}".format(k=k, v=v)
for k, v in cmd.items()]).encode('ascii')
if payload is not None:
# we add the m key to signal a multiframe communication
# appending the end (m=0) key to a single message has no effect
while len(payload) > max_slice_len:
payload_blk, payload = payload[:max_slice_len], payload[max_slice_len:]
yield self.protocol_start + \
central_blk + b',m=1;' + payload_blk + \
self.protocol_end
yield self.protocol_start + \
central_blk + b',m=0;' + payload + \
self.protocol_end
else:
yield self.protocol_start + central_blk + b';' + self.protocol_end
def quit(self):
# clear all remaining images, then check if all files went through or
# are orphaned
while self.image_id >= 1:
self.clear(0, 0, 0, 0)
# for k in self.temp_paths:
# try:
# os.remove(self.temp_paths[k])
# except (OSError, IOError):
# continue
@register_image_displayer("ueberzug")
class UeberzugImageDisplayer(ImageDisplayer):
"""Implementation of ImageDisplayer using ueberzug.
Ueberzug can display images in a Xorg session.
Does not work over ssh.
"""
IMAGE_ID = 'preview'
is_initialized = False
def __init__(self):
self.process = None
def initialize(self):
"""start ueberzug"""
if (self.is_initialized and self.process.poll() is None
and not self.process.stdin.closed):
return
# We cannot close the process because that stops the preview.
# pylint: disable=consider-using-with
with open(os.devnull, "wb") as devnull:
self.process = Popen(
["ueberzug", "layer", "--silent"],
cwd=self.working_dir,
stderr=devnull,
stdin=PIPE,
universal_newlines=True,
)
self.is_initialized = True
def _execute(self, **kwargs):
self.initialize()
self.process.stdin.write(json.dumps(kwargs) + '\n')
self.process.stdin.flush()
def draw(self, path, start_x, start_y, width, height):
self._execute(
action='add',
identifier=self.IMAGE_ID,
x=start_x,
y=start_y,
max_width=width,
max_height=height,
path=path
)
def clear(self, start_x, start_y, width, height):
if self.process and not self.process.stdin.closed:
self._execute(action='remove', identifier=self.IMAGE_ID)
def quit(self):
if self.is_initialized and self.process.poll() is None:
timer_kill = threading.Timer(1, self.process.kill, [])
try:
self.process.terminate()
timer_kill.start()
self.process.communicate()
finally:
timer_kill.cancel()
| 35,422 | Python | .py | 800 | 33.885 | 99 | 0.591569 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
732 | openstruct.py | ranger_ranger/ranger/ext/openstruct.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import collections
class OpenStruct(dict):
"""The fusion of dict and struct"""
def __init__(self, *args, **keywords):
dict.__init__(self, *args, **keywords)
self.__dict__ = self
class DefaultOpenStruct(collections.defaultdict):
"""The fusion of dict and struct, with default values"""
def __init__(self, *args, **keywords):
collections.defaultdict.__init__(self, None, *args, **keywords)
self.__dict__ = self
def __getattr__(self, name):
if name not in self.__dict__:
return None
return self.__dict__[name]
| 786 | Python | .py | 18 | 37.722222 | 71 | 0.648221 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
733 | rifle.py | ranger_ranger/ranger/ext/rifle.py | #!/usr/bin/python
# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""rifle, the file executor/opener of ranger
This can be used as a standalone program or can be embedded in python code.
When used together with ranger, it doesn't have to be installed to $PATH.
Example usage:
rifle = Rifle("rifle.conf")
rifle.reload_config()
rifle.execute(["file1", "file2"])
"""
from __future__ import (absolute_import, division, print_function)
import os.path
import re
import shlex
from subprocess import PIPE, CalledProcessError
import sys
__version__ = 'rifle 1.9.3'
# Options and constants that a user might want to change:
DEFAULT_PAGER = 'less'
DEFAULT_EDITOR = 'vim'
ASK_COMMAND = 'ask'
ENCODING = 'utf-8'
# Imports from ranger library, plus reimplementations in case ranger is not
# installed so rifle can be run as a standalone program.
try:
from ranger.ext.get_executables import get_executables
except ImportError:
_CACHED_EXECUTABLES = None
def get_executables():
"""Return all executable files in $PATH + Cache them."""
global _CACHED_EXECUTABLES # pylint: disable=global-statement
if _CACHED_EXECUTABLES is not None:
return _CACHED_EXECUTABLES
if 'PATH' in os.environ:
paths = os.environ['PATH'].split(':')
else:
paths = ['/usr/bin', '/bin']
from stat import S_IXOTH, S_IFREG
paths_seen = set()
_CACHED_EXECUTABLES = set()
for path in paths:
if path in paths_seen:
continue
paths_seen.add(path)
try:
content = os.listdir(path)
except OSError:
continue
for item in content:
abspath = path + '/' + item
try:
filestat = os.stat(abspath)
except OSError:
continue
if filestat.st_mode & (S_IXOTH | S_IFREG):
_CACHED_EXECUTABLES.add(item)
return _CACHED_EXECUTABLES
try:
from ranger.ext.popen23 import Popen23
except ImportError:
# COMPAT: Python 2 (and Python <=3.2) subprocess.Popen objects aren't
# context managers. We don't care about early Python 3 but we do
# want to wrap Python 2's Popen. There's no harm in always using
# this Popen but it is only necessary when used with
# with-statements. This can be removed once we ditch Python 2
# support.
from contextlib import contextmanager
# pylint: disable=ungrouped-imports
from subprocess import Popen
try:
from ranger import PY3
except ImportError:
from sys import version_info
PY3 = version_info[0] >= 3
@contextmanager
def Popen23(*args, **kwargs): # pylint: disable=invalid-name
if PY3:
yield Popen(*args, **kwargs)
return
else:
popen2 = Popen(*args, **kwargs)
try:
yield popen2
finally:
# From Lib/subprocess.py Popen.__exit__:
if popen2.stdout:
popen2.stdout.close()
if popen2.stderr:
popen2.stderr.close()
try: # Flushing a BufferedWriter may raise an error
if popen2.stdin:
popen2.stdin.close()
except KeyboardInterrupt:
# https://bugs.python.org/issue25942
# In the case of a KeyboardInterrupt we assume the SIGINT
# was also already sent to our child processes. We can't
# block indefinitely as that is not user friendly.
# If we have not already waited a brief amount of time in
# an interrupted .wait() or .communicate() call, do so here
# for consistency.
# pylint: disable=protected-access
if popen2._sigint_wait_secs > 0:
try:
# pylint: disable=no-member
popen2._wait(timeout=popen2._sigint_wait_secs)
except Exception: # pylint: disable=broad-except
# COMPAT: This is very broad but Python 2.7 does not
# have TimeoutExpired, nor SubprocessError
pass
popen2._sigint_wait_secs = 0 # Note that this's been done.
# pylint: disable=lost-exception
return # resume the KeyboardInterrupt
finally:
# Wait for the process to terminate, to avoid zombies.
popen2.wait()
try:
from ranger.ext.popen_forked import Popen_forked
except ImportError:
def Popen_forked(*args, **kwargs): # pylint: disable=invalid-name
"""Forks process and runs Popen with the given args and kwargs."""
try:
pid = os.fork()
except OSError:
return False
if pid == 0:
os.setsid()
# pylint: disable=unspecified-encoding
with open(os.devnull, "r") as null_r, open(
os.devnull, "w"
) as null_w:
kwargs["stdin"] = null_r
kwargs["stdout"] = kwargs["stderr"] = null_w
Popen(*args, **kwargs) # pylint: disable=consider-using-with
os._exit(0) # pylint: disable=protected-access
return True
def _is_terminal():
# Check if stdin (file descriptor 0), stdout (fd 1) and
# stderr (fd 2) are connected to a terminal
try:
os.ttyname(0)
os.ttyname(1)
os.ttyname(2)
except OSError:
return False
return True
def squash_flags(flags):
"""Remove lowercase flags if the respective uppercase flag exists
>>> squash_flags('abc')
'abc'
>>> squash_flags('abcC')
'ab'
>>> squash_flags('CabcAd')
'bd'
"""
exclude = ''.join(f.upper() + f.lower() for f in flags if f == f.upper())
return ''.join(f for f in flags if f not in exclude)
class Rifle(object): # pylint: disable=too-many-instance-attributes
delimiter1 = '='
delimiter2 = ','
# TODO: Test all of the hooks properly
def hook_before_executing(self, command, mimetype, flags):
pass
def hook_after_executing(self, command, mimetype, flags):
pass
@staticmethod
def hook_command_preprocessing(command):
return command
@staticmethod
def hook_command_postprocessing(command):
return command
@staticmethod
def hook_environment(env):
return env
@staticmethod
def hook_logger(string):
sys.stderr.write(string + "\n")
def __init__(self, config_file):
self.config_file = config_file
self._app_flags = ''
self._app_label = None
self._mimetype = None
self._skip = None
self.rules = None
# get paths for mimetype files
self._mimetype_known_files = [os.path.expanduser("~/.mime.types")]
if __file__.endswith("ranger/ext/rifle.py"):
# Add ranger's default mimetypes when run from ranger directory
self._mimetype_known_files.append(
__file__.replace("ext/rifle.py", "data/mime.types"))
def reload_config(self, config_file=None):
"""Replace the current configuration with the one in config_file"""
if config_file is None:
config_file = self.config_file
# pylint: disable=unspecified-encoding
with open(config_file, "r") as fobj:
self.rules = []
for line in fobj:
line = line.strip()
if line.startswith('#') or line == '':
continue
if self.delimiter1 not in line:
raise ValueError("Line without delimiter")
tests, command = line.split(self.delimiter1, 1)
tests = tests.split(self.delimiter2)
tests = tuple(tuple(f.strip().split(None, 1)) for f in tests)
command = command.strip()
self.rules.append((command, tests))
def _eval_condition(self, condition, files, label):
# Handle the negation of conditions starting with an exclamation mark,
# then pass on the arguments to _eval_condition2().
if not condition:
return True
if condition[0].startswith('!'):
new_condition = tuple([condition[0][1:]]) + tuple(condition[1:])
return not self._eval_condition2(new_condition, files, label)
return self._eval_condition2(condition, files, label)
def _eval_condition2( # pylint: disable=too-many-return-statements,too-many-branches
self, rule, files, label):
# This function evaluates the condition, after _eval_condition() handled
# negation of conditions starting with a "!".
if not files:
return False
function = rule[0]
argument = rule[1] if len(rule) > 1 else ''
if function == 'ext':
if os.path.isfile(files[0]):
partitions = os.path.basename(files[0]).rpartition('.')
if not partitions[0]:
return False
return bool(re.search('^(' + argument + ')$', partitions[2].lower()))
elif function == 'name':
return bool(re.search(argument, os.path.basename(files[0])))
elif function == 'match':
return bool(re.search(argument, files[0]))
elif function == 'file':
return os.path.isfile(files[0])
elif function == 'directory':
return os.path.isdir(files[0])
elif function == 'path':
return bool(re.search(argument, os.path.abspath(files[0])))
elif function == 'mime':
mimetype = self.get_mimetype(files[0])
if mimetype is None:
return False
return bool(re.search(argument, mimetype))
elif function == 'has':
if argument.startswith("$"):
if argument[1:] in os.environ:
return os.environ[argument[1:]] in get_executables()
return False
else:
return argument in get_executables()
elif function == 'terminal':
return _is_terminal()
elif function == 'number':
if argument.isdigit():
self._skip = int(argument)
return True
elif function == 'label':
self._app_label = argument
if label:
return argument == label
return True
elif function == 'flag':
self._app_flags = argument
return True
elif function == 'X':
return ('WAYLAND_DISPLAY' in os.environ
or sys.platform == 'darwin'
or 'DISPLAY' in os.environ)
elif function == 'env':
return bool(os.environ.get(argument))
elif function == 'else':
return True
return None
def get_mimetype(self, fname):
# Spawn "file" to determine the mime-type of the given file.
if self._mimetype:
return self._mimetype
import mimetypes
if not mimetypes.inited:
mimetypes.init(mimetypes.knownfiles + self._mimetype_known_files)
self._mimetype, _ = mimetypes.guess_type(fname)
if not self._mimetype:
try:
with Popen23(
["file", "--mime-type", "-Lb", fname], stdout=PIPE, stderr=PIPE
) as process:
mimetype, _ = process.communicate()
self._mimetype = mimetype.decode(ENCODING).strip()
except OSError:
self._mimetype = None
self.hook_logger("file(1) is not available to determine mime-type")
if self._mimetype == 'application/octet-stream':
try:
with Popen23(
["mimetype", "--output-format", "%m", fname],
stdout=PIPE,
stderr=PIPE,
) as process:
mimetype, _ = process.communicate()
self._mimetype = mimetype.decode(ENCODING).strip()
except OSError:
pass
return self._mimetype
def _build_command(self, files, action, flags):
# Get the flags
if isinstance(flags, str):
self._app_flags += flags
self._app_flags = squash_flags(self._app_flags)
filenames = "' '".join(f.replace("'", "'\\\''") for f in files if "\x00" not in f)
return "set -- '%s'; %s" % (filenames, action)
def list_commands(self, files, mimetype=None, skip_ask=False):
"""List all commands that are applicable for the given files
Returns one 4-tuple for all currently applicable commands
The 4-tuple contains (count, command, label, flags).
count is the index, counted from 0 upwards,
command is the command that will be executed.
label and flags are the label and flags specified in the rule.
"""
self._mimetype = mimetype
count = -1
for cmd, tests in self.rules:
self._skip = None
self._app_flags = ''
self._app_label = None
if skip_ask and cmd == ASK_COMMAND:
# TODO(vifon): Fix properly, see
# https://github.com/ranger/ranger/pull/1341#issuecomment-537264495
count += 1
continue
for test in tests:
if not self._eval_condition(test, files, None):
break
else:
if self._skip is None:
count += 1
else:
count = self._skip
yield (count, cmd, self._app_label, self._app_flags)
def execute(self, files, # noqa: E501 pylint: disable=too-many-branches,too-many-statements,too-many-locals
number=0, label=None, flags="", mimetype=None):
"""Executes the given list of files.
By default, this executes the first command where all conditions apply,
but by specifying number=N you can run the 1+Nth command.
If a label is specified, only rules with this label will be considered.
If you specify the mimetype, rifle will not try to determine it itself.
By specifying a flag, you extend the flag that is defined in the rule.
Uppercase flags negate the respective lowercase flags.
For example: if the flag in the rule is "pw" and you specify "Pf", then
the "p" flag is negated and the "f" flag is added, resulting in "wf".
"""
command = None
found_at_least_one = None
# Determine command
for count, cmd, lbl, flgs in self.list_commands(files, mimetype):
if label and label == lbl or not label and count == number:
cmd = self.hook_command_preprocessing(cmd)
if cmd == ASK_COMMAND:
return ASK_COMMAND
command = self._build_command(files, cmd, flags + flgs)
flags = self._app_flags
break
else:
found_at_least_one = True
else:
if label and label in get_executables():
cmd = '%s "$@"' % label
command = self._build_command(files, cmd, flags)
# Execute command
if command is None: # pylint: disable=too-many-nested-blocks
if found_at_least_one:
if label:
self.hook_logger("Label '%s' is undefined" % label)
else:
self.hook_logger("Method number %d is undefined." % number)
else:
self.hook_logger("No action found.")
else:
if 'PAGER' not in os.environ:
os.environ['PAGER'] = DEFAULT_PAGER
if 'EDITOR' not in os.environ:
os.environ['EDITOR'] = os.environ.get('VISUAL', DEFAULT_EDITOR)
command = self.hook_command_postprocessing(command)
self.hook_before_executing(command, self._mimetype, self._app_flags)
try:
if 'r' in flags:
prefix = ['sudo', '-E', 'su', 'root', '-mc']
else:
prefix = ['/bin/sh', '-c']
cmd = prefix + [command]
if 't' in flags:
term = os.environ.get('TERMCMD', os.environ['TERM'])
# Handle aliases of xterm and urxvt, rxvt and st and
# termite
# Match 'xterm', 'xterm-256color'
if term in ['xterm', 'xterm-256color']:
term = 'xterm'
if term in ['xterm-kitty']:
term = 'kitty'
if term in ['xterm-termite']:
term = 'termite'
if term in ['st', 'st-256color']:
term = 'st'
if term in ['urxvt', 'rxvt-unicode',
'rxvt-unicode-256color']:
term = 'urxvt'
if term in ['rxvt', 'rxvt-256color']:
if 'rxvt' in get_executables():
term = 'rxvt'
else:
term = 'urxvt'
if term not in get_executables():
self.hook_logger("Can not determine terminal command, "
"using rifle to determine fallback. "
"Please set $TERMCMD manually or "
"change fallbacks in rifle.conf.")
self._mimetype = 'ranger/x-terminal-emulator'
self.execute(
files=[command.split(';')[1].split('--')[0].strip()]
+ files, flags='f',
mimetype='ranger/x-terminal-emulator')
return None
# Choose correct cmdflag accordingly
if term in ['xfce4-terminal', 'mate-terminal',
'terminator']:
cmdflag = '-x'
elif term in ['xterm', 'urxvt', 'rxvt', 'lxterminal',
'konsole', 'lilyterm', 'cool-retro-term',
'terminology', 'pantheon-terminal', 'termite',
'st', 'stterm']:
cmdflag = '-e'
elif term in ['gnome-terminal', 'kitty']:
cmdflag = '--'
elif term in ['tilda', ]:
cmdflag = '-c'
else:
cmdflag = '-e'
os.environ['TERMCMD'] = term
# These terms don't work with the '/bin/sh set --' scheme.
# A temporary fix.
if term in ['tilda', 'pantheon-terminal', 'terminology',
'termite']:
target = command.split(';')[0].split('--')[1].strip()
app = command.split(';')[1].split('--')[0].strip()
cmd = [os.environ['TERMCMD'], cmdflag, '%s %s'
% (app, target)]
elif term in ['guake']:
cmd = [os.environ['TERMCMD'], '-n', '${PWD}', cmdflag] + cmd
else:
cmd = [os.environ['TERMCMD'], cmdflag] + cmd
# self.hook_logger('cmd: %s' %cmd)
if 'f' in flags or 't' in flags:
Popen_forked(cmd, env=self.hook_environment(os.environ))
else:
with Popen23(
cmd, env=self.hook_environment(os.environ)
) as process:
exit_code = process.wait()
if exit_code != 0:
raise CalledProcessError(exit_code, shlex.join(cmd))
finally:
self.hook_after_executing(command, self._mimetype, self._app_flags)
return None
def find_conf_path():
# Find configuration file path
if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
conf_path = os.environ['XDG_CONFIG_HOME'] + '/ranger/rifle.conf'
else:
conf_path = os.path.expanduser('~/.config/ranger/rifle.conf')
default_conf_path = conf_path
if not os.path.isfile(conf_path):
conf_path = os.path.normpath(os.path.join(os.path.dirname(__file__),
'../config/rifle.conf'))
if not os.path.isfile(conf_path):
try:
# if ranger is installed, get the configuration from ranger
import ranger
except ImportError:
pass
else:
conf_path = os.path.join(ranger.__path__[0], "config", "rifle.conf")
if not os.path.isfile(conf_path):
sys.stderr.write("Could not find a configuration file.\n"
"Please create one at %s.\n" % default_conf_path)
return None
return conf_path
def main(): # pylint: disable=too-many-locals
"""The main function which is run when you start this program directly."""
# Evaluate arguments
from optparse import OptionParser # pylint: disable=deprecated-module
parser = OptionParser(usage="%prog [-fhlpw] [files]", version=__version__)
parser.add_option('-f', type="string", default="", metavar="FLAGS",
help="use additional flags: f=fork, r=root, t=terminal. "
"Uppercase flag negates respective lowercase flags.")
parser.add_option('-l', action="store_true",
help="list possible ways to open the files (id:label:flags:command)")
parser.add_option('-p', type='string', default='0', metavar="KEYWORD",
help="pick a method to open the files. KEYWORD is either the "
"number listed by 'rifle -l' or a string that matches a label in "
"the configuration file")
parser.add_option('-w', type='string', default=None, metavar="PROGRAM",
help="open the files with PROGRAM")
parser.add_option('-c', type='string', default=None, metavar="CONFIG_FILE",
help="read config from specified file instead of default")
options, positional = parser.parse_args()
if not positional:
parser.print_help()
raise SystemExit(1)
if options.c is None:
conf_path = find_conf_path()
if not conf_path:
raise SystemExit(1)
else:
try:
conf_path = os.path.abspath(options.c)
except OSError as ex:
sys.stderr.write("Unable to access specified configuration file: {0}\n".format(ex))
raise SystemExit(1)
if not os.path.isfile(conf_path):
sys.stderr.write("Specified configuration file not found: {0}\n".format(conf_path))
raise SystemExit(1)
if options.p.isdigit():
number = int(options.p)
label = None
else:
number = 0
label = options.p
exit_code = 0
if options.w is not None and not options.l:
with Popen23([options.w] + list(positional)) as process:
exit_code = process.wait()
else:
# Start up rifle
rifle = Rifle(conf_path)
rifle.reload_config()
# print(rifle.list_commands(sys.argv[1:]))
if options.l:
for count, cmd, label, flags in rifle.list_commands(positional):
print("%d:%s:%s:%s" % (count, label or '', flags, cmd))
else:
try:
result = rifle.execute(positional, number=number, label=label, flags=options.f)
except CalledProcessError as ex:
exit_code = ex.returncode
else:
if result == ASK_COMMAND:
# TODO: implement interactive asking for file type?
print("Unknown file type: %s" %
rifle.get_mimetype(positional[0]))
sys.exit(exit_code)
if __name__ == '__main__':
if 'RANGER_DOCTEST' in os.environ:
import doctest
sys.exit(doctest.testmod()[0])
else:
main()
| 24,789 | Python | .py | 558 | 31.311828 | 112 | 0.540595 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
734 | shell_escape.py | ranger_ranger/ranger/ext/shell_escape.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Functions to escape metacharacters of arguments for shell commands."""
from __future__ import (absolute_import, division, print_function)
META_CHARS = (' ', "'", '"', '`', '&', '|', ';', '#',
'$', '!', '(', ')', '[', ']', '<', '>', '\t')
UNESCAPABLE = set(map(chr, list(range(9)) + list(range(10, 32)) + list(range(127, 256))))
# pylint: disable=consider-using-dict-comprehension
# COMPAT Dictionary comprehensions didn't exist before 2.7
META_DICT = dict([(mc, '\\' + mc) for mc in META_CHARS])
def shell_quote(string):
"""Escapes by quoting"""
return "'" + str(string).replace("'", "'\\''") + "'"
def shell_escape(arg):
"""Escapes by adding backslashes"""
arg = str(arg)
if UNESCAPABLE & set(arg):
return shell_quote(arg)
arg = arg.replace('\\', '\\\\') # make sure this comes at the start
for key, value in META_DICT.items():
arg = arg.replace(key, value)
return arg
| 1,067 | Python | .py | 22 | 44.318182 | 89 | 0.611379 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
735 | macrodict.py | ranger_ranger/ranger/ext/macrodict.py | from __future__ import absolute_import
import sys
MACRO_FAIL = "<\x01\x01MACRO_HAS_NO_VALUE\x01\01>"
def macro_val(thunk, fallback=MACRO_FAIL):
try:
return thunk()
except AttributeError:
return fallback
try:
from collections.abc import MutableMapping # pylint: disable=no-name-in-module
except ImportError:
from collections import MutableMapping # pylint: disable=deprecated-class
class MacroDict(MutableMapping):
"""Mapping that returns a fallback value when thunks error
Macros can be used in scenarios where several attributes aren't
initialized yet. To avoid errors in these cases we have to delay the
evaluation of these attributes using ``lambda``s. This
``MutableMapping`` evaluates these thunks before returning them
replacing them with a fallback value if necessary.
For convenience it also catches ``TypeError`` so you can store
non-callable values without thunking.
>>> m = MacroDict()
>>> o = type("", (object,), {})()
>>> o.existing_attribute = "I exist!"
>>> m['a'] = "plain value"
>>> m['b'] = lambda: o.non_existent_attribute
>>> m['c'] = lambda: o.existing_attribute
>>> m['a']
'plain value'
>>> m['b']
'<\\x01\\x01MACRO_HAS_NO_VALUE\\x01\\x01>'
>>> m['c']
'I exist!'
"""
def __init__(self, *args, **kwargs):
super(MacroDict, self).__init__()
self.__dict__.update(*args, **kwargs)
def __setitem__(self, key, value):
try:
real_val = value()
if real_val is None:
real_val = MACRO_FAIL
except AttributeError:
real_val = MACRO_FAIL
except TypeError:
real_val = value
self.__dict__[key] = real_val
def __getitem__(self, key):
return self.__dict__[key]
def __delitem__(self, key):
del self.__dict__[key]
def __iter__(self):
return iter(self.__dict__)
def __len__(self):
return len(self.__dict__)
def __str__(self):
return str(self.__dict__)
if __name__ == '__main__':
import doctest
sys.exit(doctest.testmod()[0])
| 2,153 | Python | .py | 60 | 29.45 | 83 | 0.615645 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
736 | lazy_property.py | ranger_ranger/ranger/ext/lazy_property.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# Based on http://blog.pythonisito.com/2008/08/lazy-descriptors.html
from __future__ import (absolute_import, division, print_function)
class lazy_property(object): # pylint: disable=invalid-name,too-few-public-methods
"""A @property-like decorator with lazy evaluation
>>> class Foo:
... counter = 0
... @lazy_property
... def answer(self):
... Foo.counter += 1
... return Foo.counter
>>> foo = Foo()
>>> foo.answer
1
>>> foo.answer
1
>>> foo.answer__reset()
>>> foo.answer
2
>>> foo.answer
2
Avoid interaction between multiple objects:
>>> bar = Foo()
>>> bar.answer
3
>>> foo.answer__reset()
>>> bar.answer
3
"""
def __init__(self, method):
self._method = method
self.__name__ = method.__name__
self.__doc__ = method.__doc__
def __get__(self, obj, cls=None):
if obj is None: # to fix issues with pydoc
return None
reset_function_name = self.__name__ + "__reset"
if not hasattr(obj, reset_function_name):
def reset_function():
setattr(obj, self.__name__, self)
del obj.__dict__[self.__name__] # force "__get__" being called
obj.__dict__[reset_function_name] = reset_function
result = self._method(obj)
obj.__dict__[self.__name__] = result
return result
if __name__ == '__main__':
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 1,666 | Python | .py | 50 | 26.86 | 83 | 0.571429 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
737 | human_readable.py | ranger_ranger/ranger/ext/human_readable.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from datetime import datetime
from ranger.core.shared import SettingsAware
def human_readable(byte_count, separator=' ', use_binary=None):
"""Convert a large number of bytes to an easily readable format.
Output depends on the binary_size_prefix setting (which is False by default)
and on the use_binary argument. The latter has priority over the former.
>>> human_readable(54, use_binary=False)
'54 B'
>>> human_readable(1500, use_binary=False)
'1.5 k'
>>> human_readable(2 ** 20 * 1023, use_binary=False)
'1.07 G'
>>> human_readable(54, use_binary=True)
'54 B'
>>> human_readable(1500, use_binary=True)
'1.46 Ki'
>>> human_readable(2 ** 20 * 1023, use_binary=True)
'1023 Mi'
"""
# handle automatically_count_files false
if byte_count is None:
return ''
if byte_count <= 0:
return '0'
if SettingsAware.settings.size_in_bytes:
return format(byte_count, 'n') # 'n' = locale-aware separator.
# If you attempt to shorten this code, take performance into consideration.
binary = SettingsAware.settings.binary_size_prefix if use_binary is None else use_binary
if binary:
prefixes = ('B', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi')
unit = 1024
else:
prefixes = ('B', 'k', 'M', 'G', 'T', 'P')
unit = 1000
ind = 0
while byte_count >= unit:
byte_count /= unit
ind += 1
format_str = '%.3g%s%s' if byte_count < 1000 else '%.4g%s%s' # e.g. 1023 requires '%.4g'
return format_str % (byte_count, separator, prefixes[ind]) if ind < len(prefixes) else '>9000'
def human_readable_time(timestamp):
"""Convert a timestamp to an easily readable format.
"""
# Hard to test because it's relative to ``now()``
date = datetime.fromtimestamp(timestamp)
datediff = datetime.now().date() - date.date()
if datediff.days >= 365:
return date.strftime("%-d %b %Y")
elif datediff.days >= 7:
return date.strftime("%-d %b")
elif datediff.days >= 1:
return date.strftime("%a")
return date.strftime("%H:%M")
if __name__ == '__main__':
# XXX: This mock class is a temporary (as of 2019-01-27) hack.
class SettingsAwareMock(object): # pylint: disable=too-few-public-methods
class settings(object): # pylint: disable=invalid-name,too-few-public-methods
size_in_bytes = False
binary_size_prefix = False
SettingsAware = SettingsAwareMock # noqa: F811
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 2,764 | Python | .py | 66 | 36.090909 | 98 | 0.646532 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
738 | iter_tools.py | ranger_ranger/ranger/ext/iter_tools.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from collections import deque
def flatten(lst):
"""Flatten an iterable.
All contained tuples, lists, deques and sets are replaced by their
elements and flattened as well.
>>> l = [1, 2, [3, [4], [5, 6]], 7]
>>> list(flatten(l))
[1, 2, 3, 4, 5, 6, 7]
>>> list(flatten(()))
[]
"""
for elem in lst:
if isinstance(elem, (tuple, list, set, deque)):
for subelem in flatten(elem):
yield subelem
else:
yield elem
def unique(iterable):
"""Return an iterable of the same type which contains unique items.
This function assumes that:
type(iterable)(list(iterable)) == iterable
which is true for tuples, lists and deques (but not for strings)
>>> unique([1, 2, 3, 1, 2, 3, 4, 2, 3, 4, 1, 1, 2])
[1, 2, 3, 4]
>>> unique(('w', 't', 't', 'f', 't', 'w'))
('w', 't', 'f')
"""
already_seen = []
for item in iterable:
if item not in already_seen:
already_seen.append(item)
return type(iterable)(already_seen)
if __name__ == '__main__':
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 1,352 | Python | .py | 39 | 28.846154 | 71 | 0.596464 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
739 | logutils.py | ranger_ranger/ranger/ext/logutils.py | from __future__ import (absolute_import, division, print_function)
import logging
from collections import deque
class QueueHandler(logging.Handler):
"""
This handler store logs events into a queue.
"""
def __init__(self, queue):
"""
Initialize an instance, using the passed queue.
"""
logging.Handler.__init__(self)
self.queue = queue
def enqueue(self, record):
"""
Enqueue a log record.
"""
self.queue.append(record)
def emit(self, record):
self.enqueue(self.format(record))
QUEUE = deque(maxlen=1000)
FMT_NORMAL = logging.Formatter(
fmt='%(asctime)s %(levelname).4s %(message)s', datefmt='%H:%M:%S')
FMT_DEBUG = logging.Formatter(
fmt='%(asctime)s.%(msecs)03d %(levelname).4s [%(name)s] %(message)s', datefmt='%H:%M:%S')
def setup_logging(debug=True, logfile=None):
"""
All the produced logs using the standard logging function
will be collected in a queue by the `queue_handler` as well
as outputted on the standard error `stderr_handler`.
The verbosity and the format of the log message is
controlled by the `debug` parameter
- debug=False:
a concise log format will be used, debug messages will be discarded
and only important message will be passed to the `stderr_handler`
- debug=True:
an extended log format will be used, all messages will be processed
by both the handlers
"""
root_logger = logging.getLogger()
if debug:
log_level = logging.DEBUG
formatter = FMT_DEBUG
else:
log_level = logging.INFO
formatter = FMT_NORMAL
handlers = []
handlers.append(QueueHandler(QUEUE))
if logfile:
if logfile == '-':
handlers.append(logging.StreamHandler())
else:
handlers.append(logging.FileHandler(logfile))
for handler in handlers:
handler.setLevel(log_level)
handler.setFormatter(formatter)
root_logger.addHandler(handler)
root_logger.setLevel(0)
| 2,091 | Python | .py | 58 | 29.137931 | 93 | 0.652282 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
740 | relative_symlink.py | ranger_ranger/ranger/ext/relative_symlink.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from os import symlink, sep
def relative_symlink(src, dst):
common_base = get_common_base(src, dst)
symlink(get_relative_source_file(src, dst, common_base), dst)
def get_relative_source_file(src, dst, common_base=None):
if common_base is None:
common_base = get_common_base(src, dst)
return '../' * dst.count('/', len(common_base)) + src[len(common_base):]
def get_common_base(src, dst):
if not src or not dst:
return '/'
i = 0
while True:
new_i = src.find(sep, i + 1)
if new_i == -1:
break
if not dst.startswith(src[:new_i + 1]):
break
i = new_i
return src[:i + 1]
| 868 | Python | .py | 23 | 31.869565 | 76 | 0.630824 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
741 | hg.py | ranger_ranger/ranger/ext/vcs/hg.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Mercurial module"""
from __future__ import (absolute_import, division, print_function)
from datetime import datetime
import json
import os
from .vcs import Vcs, VcsError
class Hg(Vcs):
"""VCS implementation for Mercurial"""
HEAD = 'tip'
_status_translations = (
('AR', 'staged'),
('M', 'changed'),
('!', 'deleted'),
('?', 'untracked'),
('I', 'ignored'),
)
# Generic
def _log(self, refspec=None, maxres=None, filelist=None):
args = ['log', '--template', 'json']
if refspec:
args += ['--limit', '1', '--rev', refspec]
elif maxres:
args += ['--limit', str(maxres)]
if filelist:
args += ['--'] + filelist
try:
output = self._run(args)
except VcsError:
return None
if not output:
return None
log = []
for entry in json.loads(output):
new = {}
new['short'] = entry['rev']
new['revid'] = entry['node']
new['author'] = entry['user']
new['date'] = datetime.fromtimestamp(entry['date'][0])
new['summary'] = entry['desc']
log.append(new)
return log
def _remote_url(self):
"""Remote url"""
try:
return self._run(['showconfig', 'paths.default']) or None
except VcsError:
return None
def _status_translate(self, code):
"""Translate status code"""
for code_x, status in self._status_translations:
if code in code_x:
return status
return 'unknown'
# Action interface
def action_add(self, filelist=None):
args = ['add']
if filelist:
args += ['--'] + filelist
self._run(args, catchout=False)
def action_reset(self, filelist=None):
args = ['forget', '--']
if filelist:
args += filelist
else:
args += self.rootvcs.status_subpaths.keys() # pylint: disable=no-member
self._run(args, catchout=False)
# Data interface
def data_status_root(self):
statuses = set()
# Paths with status
for entry in json.loads(self._run(['status', '--all', '--template', 'json'])):
if entry['status'] == 'C':
continue
statuses.add(self._status_translate(entry['status']))
if statuses:
for status in self.DIRSTATUSES:
if status in statuses:
return status
return 'sync'
def data_status_subpaths(self):
statuses = {}
# Paths with status
for entry in json.loads(self._run(['status', '--all', '--template', 'json'])):
if entry['status'] == 'C':
continue
statuses[os.path.normpath(entry['path'])] = self._status_translate(entry['status'])
return statuses
def data_status_remote(self):
if self._remote_url() is None:
return 'none'
return 'unknown'
def data_branch(self):
return self._run(['branch']) or None
def data_info(self, rev=None):
if rev is None:
rev = self.HEAD
log = self._log(refspec=rev)
if not log:
if rev == self.HEAD:
return None
else:
raise VcsError('Revision {0:s} does not exist'.format(rev))
elif len(log) == 1:
return log[0]
else:
raise VcsError('More than one instance of revision {0:s}'.format(rev))
| 3,731 | Python | .py | 108 | 24.907407 | 95 | 0.535337 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
742 | vcs.py | ranger_ranger/ranger/ext/vcs/vcs.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""VCS module"""
from __future__ import (absolute_import, division, print_function)
import os
import subprocess
import threading
import time
from io import open
from ranger.ext import spawn
# Python 2 compatibility
try:
import queue
except ImportError:
import Queue as queue # pylint: disable=import-error
class VcsError(Exception):
"""VCS exception"""
class Vcs(object): # pylint: disable=too-many-instance-attributes
"""
This class represents a version controlled path, abstracting the usual
operations from the different supported backends.
The backends are declared in REPOTYPES, and are derived
classes from Vcs with the following restrictions:
* Override ALL interface methods
* Only override interface methods
* Do NOT modify internal state. All internal state is handled by Vcs
"""
# These are abstracted revisions, representing the current index (staged files),
# the current head and nothing. Every backend should redefine them if the
# version control has a similar concept, or implement _sanitize_rev method to
# clean the rev before using them
INDEX = 'INDEX'
HEAD = 'HEAD'
NONE = 'NONE'
# Backends
REPOTYPES = {
'bzr': {'class': 'Bzr', 'setting': 'vcs_backend_bzr'},
'git': {'class': 'Git', 'setting': 'vcs_backend_git'},
'hg': {'class': 'Hg', 'setting': 'vcs_backend_hg'},
'svn': {'class': 'SVN', 'setting': 'vcs_backend_svn'},
}
# Possible directory statuses in order of importance
# statuses that should not be inherited from subpaths are disabled
DIRSTATUSES = (
'conflict',
'untracked',
'deleted',
'changed',
'staged',
# 'ignored',
'sync',
# 'none',
'unknown',
)
def init_state(self, dirobj):
self.obj = dirobj
self.path = dirobj.path
self.repotypes_settings = set(
repotype for repotype, values in self.REPOTYPES.items()
if getattr(dirobj.settings, values['setting']) in ('enabled', 'local')
)
self.root, self.repodir, self.repotype, self.links = self._find_root(self.path)
self.is_root = self.obj.path == self.root
self.is_root_link = (
self.obj.is_link and self.obj.realpath == self.root)
self.is_root_pointer = self.is_root or self.is_root_link
self.in_repodir = False
self.rootvcs = None
self.track = False
if self.root:
if self.is_root:
self.rootvcs = self
# pylint: disable=invalid-class-object
self.__class__ = globals()[self.REPOTYPES[self.repotype]['class'] + 'Root']
if not os.access(self.repodir, os.R_OK):
self.obj.vcsremotestatus = 'unknown'
self.obj.vcsstatus = 'unknown'
return
self.track = True
else:
self.rootvcs = dirobj.fm.get_directory(self.root).vcs
if self.rootvcs is None or self.rootvcs.root is None:
return
self.rootvcs.links |= self.links
# pylint: disable=invalid-class-object
self.__class__ = globals()[self.REPOTYPES[self.repotype]['class']]
self.track = self.rootvcs.track
if self.path == self.repodir or self.path.startswith(self.repodir + '/'):
self.in_repodir = True
self.track = False
def __init__(self, dirobj):
# Pylint recommends against calling __init__ explicitly and requires
# certain fields to be declared in __init__ so we set those to None.
# For some reason list fields don't have the same requirement.
self.path = None
self.init_state(dirobj)
# Generic
def _run(self, args, path=None, # pylint: disable=too-many-arguments
catchout=True, retbytes=False, rstrip_newline=True):
"""Run a command"""
if self.repotype == 'hg':
# use "chg", a faster built-in client
cmd = ['chg'] + args
else:
cmd = [self.repotype] + args
if path is None:
path = self.path
try:
if catchout:
output = spawn.check_output(cmd, cwd=path, decode=not retbytes)
if not retbytes and rstrip_newline and output.endswith('\n'):
return output[:-1]
return output
else:
with open(os.devnull, mode='w', encoding="utf-8") as fd_devnull:
subprocess.check_call(cmd, cwd=path, stdout=fd_devnull, stderr=fd_devnull)
return None
except (subprocess.CalledProcessError, OSError):
raise VcsError('{0:s}: {1:s}'.format(str(cmd), path))
def _get_repotype(self, path):
"""Get type for path"""
for repotype in self.repotypes_settings:
repodir = os.path.join(path, '.' + repotype)
if os.path.exists(repodir):
return (repodir, repotype)
return (None, None)
def _find_root(self, path):
"""Finds root path"""
links = set()
while True:
if os.path.islink(path):
links.add(path)
relpath = os.path.relpath(self.path, path)
path = os.path.realpath(path)
self.path = os.path.normpath(os.path.join(path, relpath))
repodir, repotype = self._get_repotype(path)
if repodir:
return (path, repodir, repotype, links)
path_old = path
path = os.path.dirname(path)
if path == path_old:
break
return (None, None, None, None)
def reinit(self):
"""Reinit"""
if not self.in_repodir:
if not self.track \
or (not self.is_root_pointer and self._get_repotype(self.obj.realpath)[0]) \
or not os.path.exists(self.repodir):
self.init_state(self.obj)
# Action interface
def action_add(self, filelist):
"""Adds files to the index"""
raise NotImplementedError
def action_reset(self, filelist):
"""Removes files from the index"""
raise NotImplementedError
# Data interface
def data_status_root(self):
"""Returns status of self.root cheaply"""
raise NotImplementedError
def data_status_subpaths(self):
"""
Returns a dict indexed by subpaths not in sync with their status as values.
Paths are given relative to self.root
"""
raise NotImplementedError
def data_status_remote(self):
"""
Returns remote status of repository
One of ('sync', 'ahead', 'behind', 'diverged', 'none')
"""
raise NotImplementedError
def data_branch(self):
"""Returns the current named branch, if this makes sense for the backend. None otherwise"""
raise NotImplementedError
def data_info(self, rev=None):
"""Returns info string about revision rev. None in special cases"""
raise NotImplementedError
class VcsRoot(Vcs): # pylint: disable=abstract-method
"""Vcs root"""
rootinit = False
head = None
branch = None
updatetime = None
status_subpaths = None
def _status_root(self):
"""Returns root status"""
if self.status_subpaths is None:
return 'none'
statuses = set(status for path, status in self.status_subpaths.items())
for status in self.DIRSTATUSES:
if status in statuses:
return status
return 'sync'
def init_root(self):
"""Initialize root cheaply"""
try:
self.head = self.data_info(self.HEAD)
self.branch = self.data_branch()
self.obj.vcsremotestatus = self.data_status_remote()
self.obj.vcsstatus = self.data_status_root()
except VcsError as ex:
self.obj.fm.notify('VCS Exception: View log for more info', bad=True, exception=ex)
return False
self.rootinit = True
return True
def update_root(self):
"""Update root state"""
try:
self.head = self.data_info(self.HEAD)
self.branch = self.data_branch()
self.status_subpaths = self.data_status_subpaths()
self.obj.vcsremotestatus = self.data_status_remote()
self.obj.vcsstatus = self._status_root()
except VcsError as ex:
self.obj.fm.notify('VCS Exception: View log for more info', bad=True, exception=ex)
return False
self.rootinit = True
self.updatetime = time.time()
return True
def _update_walk(self, path, purge): # pylint: disable=too-many-branches
"""Update walk"""
for wroot, wdirs, _ in os.walk(path):
# Only update loaded directories
try:
wrootobj = self.obj.fm.directories[wroot]
except KeyError:
wdirs[:] = []
continue
if not wrootobj.vcs.track:
wdirs[:] = []
continue
if wrootobj.content_loaded:
has_vcschild = False
for fsobj in wrootobj.files_all:
if purge:
if fsobj.is_directory:
fsobj.vcsstatus = None
fsobj.vcs.init_state(fsobj)
else:
fsobj.vcsstatus = None
continue
if fsobj.is_directory:
fsobj.vcs.reinit()
if not fsobj.vcs.track:
continue
if fsobj.vcs.is_root_pointer:
has_vcschild = True
else:
fsobj.vcsstatus = self.status_subpath(
os.path.join(wrootobj.realpath, fsobj.basename),
is_directory=True,
)
else:
fsobj.vcsstatus = self.status_subpath(
os.path.join(wrootobj.realpath, fsobj.basename))
wrootobj.has_vcschild = has_vcschild
# Remove dead directories
for wdir in list(wdirs):
try:
wdirobj = self.obj.fm.directories[os.path.join(wroot, wdir)]
except KeyError:
wdirs.remove(wdir)
continue
if not wdirobj.vcs.track or wdirobj.vcs.is_root_pointer:
wdirs.remove(wdir)
def update_tree(self, purge=False):
"""Update tree state"""
self._update_walk(self.path, purge)
for path in list(self.links):
self._update_walk(path, purge)
try:
dirobj = self.obj.fm.directories[path]
except KeyError:
self.links.remove(path)
continue
if purge:
dirobj.vcsstatus = None
dirobj.vcs.init_state(dirobj)
elif dirobj.vcs.path == self.path:
dirobj.vcsremotestatus = self.obj.vcsremotestatus
dirobj.vcsstatus = self.obj.vcsstatus
if purge:
self.init_state(self.obj)
def check_outdated(self):
"""Check if root is outdated"""
if self.updatetime is None:
return True
for wroot, wdirs, _ in os.walk(self.path):
wrootobj = self.obj.fm.get_directory(wroot)
wrootobj.load_if_outdated()
if wroot != self.path and wrootobj.vcs.is_root_pointer:
wdirs[:] = []
continue
if wrootobj.stat and self.updatetime < wrootobj.stat.st_mtime:
return True
if wrootobj.files_all:
for wfile in wrootobj.files_all:
if wfile.stat and self.updatetime < wfile.stat.st_mtime:
return True
return False
def status_subpath(self, path, is_directory=False):
"""
Returns the status of path
path needs to be self.obj.path or subpath thereof
"""
if self.status_subpaths is None:
return 'none'
relpath = os.path.relpath(path, self.path)
# check if relpath or its parents has a status
tmppath = relpath
while tmppath:
if tmppath in self.status_subpaths:
return self.status_subpaths[tmppath]
tmppath = os.path.dirname(tmppath)
# check if path contains some file in status
if is_directory:
statuses = set(status for subpath, status in self.status_subpaths.items()
if subpath.startswith(relpath + '/'))
for status in self.DIRSTATUSES:
if status in statuses:
return status
return 'sync'
class VcsThread(threading.Thread): # pylint: disable=too-many-instance-attributes
"""VCS thread"""
def __init__(self, ui):
super(VcsThread, self).__init__()
self.daemon = True
self._ui = ui
self._queue = queue.Queue()
self.__stop = threading.Event()
self.stopped = threading.Event()
self._advance = threading.Event()
self._advance.set()
self.paused = threading.Event()
self._awoken = threading.Event()
self._redraw = False
self._roots = set()
def _is_targeted(self, dirobj):
"""Check if dirobj is targeted"""
if self._ui.browser.main_column and self._ui.browser.main_column.target == dirobj:
return True
return False
def _update_subroots(self, fsobjs):
"""Update subroots"""
if not fsobjs:
return False
has_vcschild = False
for fsobj in fsobjs:
if not fsobj.is_directory or not fsobj.vcs or not fsobj.vcs.track:
continue
rootvcs = fsobj.vcs.rootvcs
if fsobj.vcs.is_root_pointer:
has_vcschild = True
if not rootvcs.rootinit and not self._is_targeted(rootvcs.obj):
self._roots.add(rootvcs.path)
if not rootvcs.init_root():
rootvcs.update_tree(purge=True)
self._redraw = True
if fsobj.is_link:
fsobj.vcsstatus = rootvcs.obj.vcsstatus
fsobj.vcsremotestatus = rootvcs.obj.vcsremotestatus
self._redraw = True
return has_vcschild
def _queue_process(self): # pylint: disable=too-many-branches
"""Process queue"""
dirobjs = []
paths = set()
self._roots.clear()
while True:
try:
dirobjs.append(self._queue.get(block=False))
except queue.Empty:
break
for dirobj in dirobjs:
if dirobj.path in paths:
continue
paths.add(dirobj.path)
dirobj.vcs.reinit()
if dirobj.vcs.track:
rootvcs = dirobj.vcs.rootvcs
if rootvcs.path not in self._roots and rootvcs.check_outdated():
self._roots.add(rootvcs.path)
if rootvcs.update_root():
rootvcs.update_tree()
else:
rootvcs.update_tree(purge=True)
self._redraw = True
has_vcschild = self._update_subroots(dirobj.files_all)
if dirobj.has_vcschild != has_vcschild:
dirobj.has_vcschild = has_vcschild
self._redraw = True
def run(self):
while True:
self.paused.set()
self._advance.wait()
self._awoken.wait()
if self.__stop.is_set():
self.stopped.set()
return
if not self._advance.is_set():
continue
self._awoken.clear()
self.paused.clear()
try:
self._queue_process()
if self._redraw:
self._redraw = False
for column in self._ui.browser.columns:
if column.target and column.target.is_directory:
column.need_redraw = True
self._ui.status.need_redraw = True
self._ui.redraw()
except Exception as ex: # pylint: disable=broad-except
self._ui.fm.notify('VCS Exception: View log for more info', bad=True, exception=ex)
def stop(self):
"""Stop thread synchronously"""
self.__stop.set()
self.paused.wait(5)
self._advance.set()
self._awoken.set()
self.stopped.wait(1)
return self.stopped.is_set()
def pause(self):
"""Pause thread"""
self._advance.clear()
def unpause(self):
"""Unpause thread"""
self._advance.set()
def process(self, dirobj):
"""Process dirobj"""
self._queue.put(dirobj)
self._awoken.set()
# Backend imports
from .bzr import Bzr # NOQA pylint: disable=wrong-import-position
from .git import Git # NOQA pylint: disable=wrong-import-position
from .hg import Hg # NOQA pylint: disable=wrong-import-position
from .svn import SVN # NOQA pylint: disable=wrong-import-position
class BzrRoot(VcsRoot, Bzr):
"""Bzr root"""
class GitRoot(VcsRoot, Git):
"""Git root"""
class HgRoot(VcsRoot, Hg):
"""Hg root"""
class SVNRoot(VcsRoot, SVN):
"""SVN root"""
| 18,054 | Python | .py | 447 | 28.416107 | 99 | 0.558829 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
743 | git.py | ranger_ranger/ranger/ext/vcs/git.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Git module"""
from __future__ import (absolute_import, division, print_function)
from datetime import datetime
import os
import re
import unicodedata
from .vcs import Vcs, VcsError
def string_control_replace(string, replacement):
"""Replace all unicode control characters with replacement"""
return ''.join(
(replacement if unicodedata.category(char)[0] == 'C' else char for char in string))
class Git(Vcs):
"""VCS implementation for Git"""
_status_translations = (
('MADRC', ' ', 'staged'),
(' MADRC', 'M', 'changed'),
(' MARC', 'D', 'deleted'),
('D', 'DU', 'conflict'),
('A', 'AU', 'conflict'),
('U', 'ADU', 'conflict'),
('?', '?', 'untracked'),
('!', '!', 'ignored'),
)
# Generic
def _head_ref(self):
"""Returns HEAD reference"""
return self._run(['symbolic-ref', self.HEAD]) or None
def _remote_ref(self, ref):
"""Returns remote reference associated to given ref"""
if ref is None:
return None
return self._run(['for-each-ref', '--format=%(upstream)', ref]) or None
def _log(self, refspec=None, maxres=None, filelist=None):
"""Returns an array of dicts containing revision info for refspec"""
args = ['--no-pager', 'log', '--pretty=%h%x00%H%x00%an <%ae>%x00%ct%x00%s%x00%x00']
if refspec:
args += ['-1', refspec]
elif maxres:
args += ['-{0:d}'.format(maxres)]
if filelist:
args += ['--'] + filelist
try:
output = self._run(args)
except VcsError:
return None
if not output:
return None
log = []
for line in output[:-2].split('\0\0\n'):
commit_hash_abbrev, commit_hash, author, timestamp, subject = line.split('\0')
log.append({
'short': commit_hash_abbrev,
'revid': commit_hash,
'author': string_control_replace(author, ' '),
'date': datetime.fromtimestamp(int(timestamp)),
'summary': string_control_replace(subject, ' '),
})
return log
def _status_translate(self, code):
"""Translate status code"""
for code_x, code_y, status in self._status_translations:
if code[0] in code_x and code[1] in code_y:
return status
return 'unknown'
# Action interface
def action_add(self, filelist=None):
args = ['add', '--all']
if filelist:
args += ['--'] + filelist
self._run(args, catchout=False)
def action_reset(self, filelist=None):
args = ['reset']
if filelist:
args += ['--'] + filelist
self._run(args, catchout=False)
# Data Interface
def data_status_root(self):
statuses = set()
# Paths with status
skip = False
lines = self._run(['status', '--porcelain', '-z']).split('\0')[:-1]
if not lines:
return 'sync'
for line in lines:
if skip:
skip = False
continue
statuses.add(self._status_translate(line[:2]))
if line.startswith('R'):
skip = True
for status in self.DIRSTATUSES:
if status in statuses:
return status
return 'sync'
def data_status_subpaths(self):
statuses = {}
# Ignored directories
paths = self._run([
'ls-files', '-z', '--others', '--directory', '--ignored', '--exclude-standard'
]).split('\0')[:-1]
for path in paths:
if path.endswith('/'):
statuses[os.path.normpath(path)] = 'ignored'
# Empty directories
paths = self._run(
['ls-files', '-z', '--others', '--directory', '--exclude-standard']).split('\0')[:-1]
for path in paths:
if path.endswith('/'):
statuses[os.path.normpath(path)] = 'none'
# Paths with status
lines = self._run(['status', '--porcelain', '-z', '--ignored']).split('\0')[:-1]
skip = False
for line in lines:
if skip:
skip = False
continue
statuses[os.path.normpath(line[3:])] = self._status_translate(line[:2])
if line.startswith('R'):
skip = True
return statuses
def data_status_remote(self):
try:
head = self._head_ref()
remote = self._remote_ref(head)
except VcsError:
head = remote = None
if not head or not remote:
return 'none'
output = self._run(['rev-list', '--left-right', '{0:s}...{1:s}'.format(remote, head)])
# pylint: disable=no-member
ahead = re.search(r'^>', output, flags=re.MULTILINE)
behind = re.search(r'^<', output, flags=re.MULTILINE)
# pylint: enable=no-member
if ahead:
return 'diverged' if behind else 'ahead'
return 'behind' if behind else 'sync'
def data_branch(self):
try:
head = self._head_ref()
except VcsError:
head = None
if head is None:
return 'detached'
match = re.match('refs/heads/(.+)', head)
return match.group(1) if match else None
def data_info(self, rev=None):
if rev is None:
rev = self.HEAD
log = self._log(refspec=rev)
if not log:
if rev == self.HEAD:
return None
else:
raise VcsError('Revision {0:s} does not exist'.format(rev))
elif len(log) == 1:
return log[0]
else:
raise VcsError('More than one instance of revision {0:s}'.format(rev))
| 5,980 | Python | .py | 160 | 27.375 | 97 | 0.533368 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
744 | __init__.py | ranger_ranger/ranger/ext/vcs/__init__.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""VCS Extension"""
from __future__ import (absolute_import, division, print_function)
from .vcs import Vcs, VcsError, VcsThread
__all__ = ['Vcs', 'VcsError', 'VcsThread']
| 299 | Python | .py | 6 | 48.166667 | 66 | 0.726644 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
745 | svn.py | ranger_ranger/ranger/ext/vcs/svn.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Subversion module"""
from __future__ import (absolute_import, division, print_function)
from datetime import datetime
import os
from xml.etree import ElementTree as etree
from .vcs import Vcs, VcsError
class SVN(Vcs):
"""VCS implementation for Subversion"""
# Generic
_status_translations = (
('ADR', 'staged'),
('C', 'conflict'),
('I', 'ignored'),
('M~', 'changed'),
('X', 'none'),
('?', 'untracked'),
('!', 'deleted'),
)
def _log(self, refspec=None, maxres=None, filelist=None):
"""Retrieves log message and parses it"""
args = ['log', '--xml']
if refspec:
args += ['--limit', '1', '--revision', refspec]
elif maxres:
args += ['--limit', str(maxres)]
if filelist:
args += ['--'] + filelist
try:
output = self._run(args)
except VcsError:
return None
if not output:
return None
log = []
for entry in etree.fromstring(output).findall('./logentry'):
new = {}
new['short'] = entry.get('revision')
new['revid'] = entry.get('revision')
new['author'] = entry.find('./author').text
new['date'] = datetime.strptime(
entry.find('./date').text,
'%Y-%m-%dT%H:%M:%S.%fZ',
)
new['summary'] = entry.find('./msg').text.split('\n')[0]
log.append(new)
return log
def _status_translate(self, code):
"""Translate status code"""
for code_x, status in self._status_translations:
if code in code_x:
return status
return 'unknown'
def _remote_url(self):
"""Remote url"""
try:
output = self._run(['info', '--xml'])
except VcsError:
return None
if not output:
return None
return etree.fromstring(output).find('./entry/url').text or None
# Action Interface
def action_add(self, filelist=None):
args = ['add']
if filelist:
args += ['--'] + filelist
self._run(args, catchout=False)
def action_reset(self, filelist=None):
args = ['revert', '--']
if filelist:
args += filelist
else:
args += self.rootvcs.status_subpaths.keys() # pylint: disable=no-member
self._run(args, catchout=False)
# Data Interface
def data_status_root(self):
statuses = set()
# Paths with status
lines = self._run(['status']).split('\n')
lines = list(filter(None, lines))
if not lines:
return 'sync'
for line in lines:
code = line[0]
if code == ' ':
continue
statuses.add(self._status_translate(code))
for status in self.DIRSTATUSES:
if status in statuses:
return status
return 'sync'
def data_status_subpaths(self):
statuses = {}
# Paths with status
lines = self._run(['status']).split('\n')
lines = list(filter(None, lines))
for line in lines:
code, path = line[0], line[8:]
if code == ' ':
continue
statuses[os.path.normpath(path)] = self._status_translate(code)
return statuses
def data_status_remote(self):
remote = self._remote_url()
if remote is None or remote.startswith('file://'):
return 'none'
return 'unknown'
def data_branch(self):
return None
def data_info(self, rev=None):
if rev is None:
rev = self.HEAD
log = self._log(refspec=rev)
if not log:
if rev == self.HEAD:
return None
else:
raise VcsError('Revision {0:s} does not exist'.format(rev))
elif len(log) == 1:
return log[0]
else:
raise VcsError('More than one instance of revision {0:s}'.format(rev))
| 4,228 | Python | .py | 124 | 24.330645 | 84 | 0.529311 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
746 | bzr.py | ranger_ranger/ranger/ext/vcs/bzr.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""GNU Bazaar module"""
from __future__ import (absolute_import, division, print_function)
from datetime import datetime
import os
import re
from .vcs import Vcs, VcsError
class Bzr(Vcs):
"""VCS implementation for GNU Bazaar"""
HEAD = 'last:1'
_status_translations = (
('+ -R', 'K NM', 'staged'),
(' -', 'D', 'deleted'),
('?', ' ', 'untracked'),
)
# Generic
def _remote_url(self):
"""Remote url"""
try:
return self._run(['config', 'parent_location']) or None
except VcsError:
return None
def _log(self, refspec=None, filelist=None):
"""Returns an array of dicts containing revision info for refspec"""
args = ['log', '--log-format', 'long', '--levels', '0', '--show-ids']
if refspec:
args += ['--revision', refspec]
if filelist:
args += ['--'] + filelist
try:
output = self._run(args)
except VcsError:
return None
# pylint: disable=no-member
entries = re.findall(r'-+\n(.+?)\n(?:-|\Z)', output, re.MULTILINE | re.DOTALL)
# pylint: enable=no-member
log = []
for entry in entries:
new = {}
try:
new['short'] = re.search(r'^revno: ([0-9]+)', entry, re.MULTILINE).group(1)
new['revid'] = re.search(r'^revision-id: (.+)$', entry, re.MULTILINE).group(1)
new['author'] = re.search(r'^committer: (.+)$', entry, re.MULTILINE).group(1)
new['date'] = datetime.strptime(
re.search(r'^timestamp: (.+)$', entry, re.MULTILINE).group(1),
'%a %Y-%m-%d %H:%M:%S %z'
)
new['summary'] = re.search(r'^message:\n (.+)$', entry, re.MULTILINE).group(1)
except AttributeError:
return None
log.append(new)
return log
def _status_translate(self, code):
"""Translate status code"""
for code_x, code_y, status in self._status_translations:
if code[0] in code_x and code[1] in code_y:
return status
return 'unknown'
# Action Interface
def action_add(self, filelist=None):
args = ['add']
if filelist:
args += ['--'] + filelist
self._run(args, catchout=False)
def action_reset(self, filelist=None):
args = ['remove', '--keep', '--new']
if filelist:
args += ['--'] + filelist
self._run(args, catchout=False)
# Data Interface
def data_status_root(self):
statuses = set()
# Paths with status
lines = self._run(['status', '--short', '--no-classify']).split('\n')
if not lines:
return 'sync'
for line in lines:
statuses.add(self._status_translate(line[:2]))
for status in self.DIRSTATUSES:
if status in statuses:
return status
return 'sync'
def data_status_subpaths(self):
statuses = {}
# Ignored
paths = self._run(['ls', '--null', '--ignored']).split('\0')[:-1]
for path in paths:
statuses[path] = 'ignored'
# Paths with status
lines = self._run(['status', '--short', '--no-classify']).split('\n')
for line in lines:
statuses[os.path.normpath(line[4:])] = self._status_translate(line[:2])
return statuses
def data_status_remote(self):
if not self._remote_url():
return 'none'
return 'unknown'
def data_branch(self):
try:
return self._run(['nick']) or None
except VcsError:
return None
def data_info(self, rev=None):
if rev is None:
rev = self.HEAD
log = self._log(refspec=rev)
if not log:
if rev == self.HEAD:
return None
else:
raise VcsError('Revision {0:s} does not exist'.format(rev))
elif len(log) == 1:
return log[0]
else:
raise VcsError('More than one instance of revision {0:s}'.format(rev))
| 4,320 | Python | .py | 116 | 27.336207 | 95 | 0.529581 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
747 | __init__.py | ranger_ranger/ranger/api/__init__.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Files in this module contain helper functions used in configuration files."""
from __future__ import (absolute_import, division, print_function)
import ranger
from ranger.core.linemode import LinemodeBase
__all__ = ['ranger', 'LinemodeBase', 'hook_init', 'hook_ready', 'register_linemode']
# Hooks for use in plugins:
def hook_init(fm): # pylint: disable=unused-argument
"""A hook that is called when ranger starts up.
Parameters:
fm = the file manager instance
Return Value:
ignored
This hook is executed after fm is initialized but before fm.ui is
initialized. You can safely print to stdout and have access to fm to add
keybindings and such.
"""
def hook_ready(fm): # pylint: disable=unused-argument
"""A hook that is called after the ranger UI is initialized.
Parameters:
fm = the file manager instance
Return Value:
ignored
This hook is executed after the user interface is initialized. You should
NOT print anything to stdout anymore from here on. Use fm.notify instead.
"""
def register_linemode(linemode_class):
"""Add a custom linemode class. See ranger.core.linemode"""
from ranger.container.fsobject import FileSystemObject
FileSystemObject.linemode_dict[linemode_class.name] = linemode_class()
return linemode_class
| 1,467 | Python | .py | 32 | 41.5 | 84 | 0.738028 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
748 | commands.py | ranger_ranger/ranger/api/commands.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# TODO: Add an optional "!" to all commands and set a flag if it's there
from __future__ import (absolute_import, division, print_function)
import os
import re
import ranger
from ranger import MACRO_DELIMITER, MACRO_DELIMITER_ESC
from ranger.core.shared import FileManagerAware
from ranger.ext.lazy_property import lazy_property
from ranger.api import LinemodeBase, hook_init, hook_ready, register_linemode # COMPAT
__all__ = ['Command', 'LinemodeBase', 'hook_init', 'hook_ready', 'register_linemode'] # COMPAT
_SETTINGS_RE = re.compile(r'^\s*([^\s]+?)=(.*)$')
_ALIAS_LINE_RE = re.compile(r'(\s+)')
def _command_init(cls):
# Escape macros for tab completion
if cls.resolve_macros:
tab_old = cls.tab
def tab(self, tabnum):
results = tab_old(self, tabnum)
if results is None:
return None
elif isinstance(results, str):
return results.replace(MACRO_DELIMITER, MACRO_DELIMITER_ESC)
elif hasattr(results, '__iter__'):
return (result.replace(MACRO_DELIMITER, MACRO_DELIMITER_ESC) for result in results)
return None
setattr(cls, 'tab', tab)
return cls
class CommandContainer(FileManagerAware):
def __init__(self):
self.commands = {}
def __getitem__(self, key):
return self.commands[key]
def alias(self, name, full_command):
cmd_name = full_command.split()[0]
cmd_cls = self.get_command(cmd_name)
if cmd_cls is None:
self.fm.notify('alias failed: No such command: {0}'.format(cmd_name), bad=True)
else:
self.commands[name] = _command_init(command_alias_factory(name, cmd_cls, full_command))
def load_commands_from_module(self, module):
for var in vars(module).values():
try:
if issubclass(var, Command) and var != Command:
self.commands[var.get_name()] = _command_init(var)
except TypeError:
pass
def load_commands_from_object(self, obj, filtr):
for attribute_name in dir(obj):
if attribute_name[0] == '_' or attribute_name not in filtr:
continue
attribute = getattr(obj, attribute_name)
if hasattr(attribute, '__call__'):
self.commands[attribute_name] = _command_init(command_function_factory(attribute))
def get_command(self, name, abbrev=False):
if abbrev:
lst = [cls for cmd, cls in self.commands.items()
if cls.allow_abbrev and cmd.startswith(name) or cmd == name]
if not lst:
raise KeyError
if len(lst) == 1:
return lst[0]
if self.commands[name] in lst:
return self.commands[name]
raise ValueError("Ambiguous command")
try:
return self.commands[name]
except KeyError:
return None
def command_generator(self, start):
return sorted(cmd + ' ' for cmd in self.commands if cmd.startswith(start))
class Command(FileManagerAware):
"""Abstract command class"""
name = None
allow_abbrev = True
resolve_macros = True
escape_macros_for_shell = False
quantifier = None
_shifted = 0
_setting_line = None
def __init__(self, line, quantifier=None):
self.init_line(line)
self.quantifier = quantifier
self.quickly_executed = False
def init_line(self, line):
self.line = line
self.args = line.split()
try:
self.firstpart = line[:line.rindex(' ') + 1]
except ValueError:
self.firstpart = ''
@classmethod
def get_name(cls):
classdict = cls.__mro__[0].__dict__
if 'name' in classdict and classdict['name']:
return cls.name
return cls.__name__
def execute(self):
"""Override this"""
def tab(self, tabnum):
"""Override this"""
def quick(self):
"""Override this"""
def cancel(self):
"""Override this"""
# Easy ways to get information
def arg(self, n):
"""Returns the nth space separated word"""
try:
return self.args[n]
except IndexError:
return ""
def rest(self, n):
"""Returns everything from and after arg(n)"""
got_space = True
word_count = 0
for i, char in enumerate(self.line):
if char.isspace():
if not got_space:
got_space = True
word_count += 1
elif got_space:
got_space = False
if word_count == n + self._shifted:
return self.line[i:]
return ""
def start(self, n):
"""Returns everything until (inclusively) arg(n)"""
return ' '.join(self.args[:n]) + " " # XXX
def shift(self):
del self.args[0]
self._setting_line = None
self._shifted += 1
def parse_setting_line(self):
"""
Parses the command line argument that is passed to the `:set` command.
Returns [option, value, name_complete].
Can parse incomplete lines too, and `name_complete` is a boolean
indicating whether the option name looks like it's completed or
unfinished. This is useful for generating tab completions.
>>> Command("set foo=bar").parse_setting_line()
['foo', 'bar', True]
>>> Command("set foo").parse_setting_line()
['foo', '', False]
>>> Command("set foo=").parse_setting_line()
['foo', '', True]
>>> Command("set foo ").parse_setting_line()
['foo', '', True]
>>> Command("set myoption myvalue").parse_setting_line()
['myoption', 'myvalue', True]
>>> Command("set").parse_setting_line()
['', '', False]
"""
if self._setting_line is not None:
return self._setting_line
match = _SETTINGS_RE.match(self.rest(1))
if match:
self.firstpart += match.group(1) + '='
result = [match.group(1), match.group(2), True]
else:
result = [self.arg(1), self.rest(2), ' ' in self.rest(1)]
self._setting_line = result
return result
def parse_setting_line_v2(self):
"""
Parses the command line argument that is passed to the `:set` command.
Returns [option, value, name_complete, toggle].
>>> Command("set foo=bar").parse_setting_line_v2()
['foo', 'bar', True, False]
>>> Command("set foo!").parse_setting_line_v2()
['foo', '', True, True]
"""
option, value, name_complete = self.parse_setting_line()
if len(option) >= 2 and option[-1] == '!':
toggle = True
option = option[:-1]
name_complete = True
else:
toggle = False
return [option, value, name_complete, toggle]
def parse_flags(self):
"""Finds and returns flags in the command
>>> Command("").parse_flags()
('', '')
>>> Command("foo").parse_flags()
('', '')
>>> Command("shell test").parse_flags()
('', 'test')
>>> Command("shell -t ls -l").parse_flags()
('t', 'ls -l')
>>> Command("shell -f -- -q test").parse_flags()
('f', '-q test')
>>> Command("shell -foo -bar rest of the command").parse_flags()
('foobar', 'rest of the command')
"""
flags = ""
args = self.line.split()
rest = ""
if args:
rest = self.line[len(args[0]):].lstrip()
for arg in args[1:]:
if arg == "--":
rest = rest[2:].lstrip()
break
elif len(arg) > 1 and arg[0] == "-":
rest = rest[len(arg):].lstrip()
flags += arg[1:]
else:
break
return flags, rest
@lazy_property
def log(self):
import logging
return logging.getLogger('ranger.commands.' + self.__class__.__name__)
# COMPAT: this is still used in old commands.py configs
def _tab_only_directories(self):
from os.path import dirname, basename, expanduser, join
cwd = self.fm.thisdir.path
rel_dest = self.rest(1)
# expand the tilde into the user directory
if rel_dest.startswith('~'):
rel_dest = expanduser(rel_dest)
# define some shortcuts
abs_dest = join(cwd, rel_dest)
abs_dirname = dirname(abs_dest)
rel_basename = basename(rel_dest)
rel_dirname = dirname(rel_dest)
try:
# are we at the end of a directory?
if rel_dest.endswith('/') or rel_dest == '':
_, dirnames, _ = next(os.walk(abs_dest))
# are we in the middle of the filename?
else:
_, dirnames, _ = next(os.walk(abs_dirname))
dirnames = [dn for dn in dirnames
if dn.startswith(rel_basename)]
except (OSError, StopIteration):
# os.walk found nothing
return None
else:
dirnames.sort()
# no results, return None
if not dirnames:
return None
# one result. since it must be a directory, append a slash.
if len(dirnames) == 1:
return self.start(1) + join(rel_dirname, dirnames[0]) + '/'
# more than one result. append no slash, so the user can
# manually type in the slash to advance into that directory
return (self.start(1) + join(rel_dirname, dirname)
for dirname in dirnames)
def _tab_directory_content(self): # pylint: disable=too-many-locals
from os.path import dirname, basename, expanduser, join
cwd = self.fm.thisdir.path
rel_dest = self.rest(1)
# expand the tilde into the user directory
if rel_dest.startswith('~'):
rel_dest = expanduser(rel_dest)
# define some shortcuts
abs_dest = join(cwd, rel_dest)
abs_dirname = dirname(abs_dest)
rel_basename = basename(rel_dest)
rel_dirname = dirname(rel_dest)
try:
directory = self.fm.get_directory(abs_dest)
# are we at the end of a directory?
if rel_dest.endswith('/') or rel_dest == '':
if directory.content_loaded:
# Take the order from the directory object
names = [f.basename for f in directory.files]
if self.fm.thisfile.basename in names:
i = names.index(self.fm.thisfile.basename)
names = names[i:] + names[:i]
else:
# Fall back to old method with "os.walk"
_, dirnames, filenames = next(os.walk(abs_dest))
names = sorted(dirnames + filenames)
# are we in the middle of the filename?
else:
if directory.content_loaded:
# Take the order from the directory object
names = [f.basename for f in directory.files
if f.basename.startswith(rel_basename)]
if self.fm.thisfile.basename in names:
i = names.index(self.fm.thisfile.basename)
names = names[i:] + names[:i]
else:
# Fall back to old method with "os.walk"
_, dirnames, filenames = next(os.walk(abs_dirname))
names = sorted([name for name in (dirnames + filenames)
if name.startswith(rel_basename)])
except (OSError, StopIteration):
# os.walk found nothing
return None
else:
# no results, return None
if not names:
return None
# one result. append a slash if it's a directory
if len(names) == 1:
path = join(rel_dirname, names[0])
slash = '/' if os.path.isdir(path) else ''
return self.start(1) + path + slash
# more than one result. append no slash, so the user can
# manually type in the slash to advance into that directory
return (self.start(1) + join(rel_dirname, name) for name in names)
def _tab_through_executables(self):
from ranger.ext.get_executables import get_executables
programs = [program for program in get_executables() if
program.startswith(self.rest(1))]
if not programs:
return None
if len(programs) == 1:
return self.start(1) + programs[0]
programs.sort()
return (self.start(1) + program for program in programs)
def command_alias_factory(name, cls, full_command):
class CommandAlias(cls): # pylint: disable=too-few-public-methods
def __init__(self, line, *args, **kwargs):
super(CommandAlias, self).__init__(
(full_command + ''.join(_ALIAS_LINE_RE.split(line)[1:])), *args, **kwargs)
CommandAlias.__name__ = name
return CommandAlias
def command_function_factory(func):
class CommandFunction(Command):
__doc__ = func.__doc__
def execute(self):
# pylint: disable=too-many-branches,too-many-return-statements
if not func:
return None
if len(self.args) == 1:
try:
return func(**{'narg': self.quantifier})
except TypeError:
return func()
args, kwargs = [], {}
for arg in self.args[1:]:
equal_sign = arg.find("=")
value = arg if equal_sign == -1 else arg[equal_sign + 1:]
try:
value = int(value)
except ValueError:
if value in ('True', 'False'):
value = (value == 'True')
else:
try:
value = float(value)
except ValueError:
pass
if equal_sign == -1:
args.append(value)
else:
kwargs[arg[:equal_sign]] = value
if self.quantifier is not None:
kwargs['narg'] = self.quantifier
try:
if self.quantifier is None:
return func(*args, **kwargs)
else:
try:
return func(*args, **kwargs)
except TypeError:
del kwargs['narg']
return func(*args, **kwargs)
except TypeError:
if ranger.args.debug:
raise
self.fm.notify("Bad arguments for %s: %s, %s" % (func.__name__, args, kwargs),
bad=True)
return None
CommandFunction.__name__ = func.__name__
return CommandFunction
if __name__ == '__main__':
import doctest
import sys
sys.exit(doctest.testmod()[0])
| 15,567 | Python | .py | 377 | 29.381963 | 99 | 0.537718 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
749 | default.py | ranger_ranger/ranger/colorschemes/default.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from ranger.gui.colorscheme import ColorScheme
from ranger.gui.color import (
black, blue, cyan, green, magenta, red, white, yellow, default,
normal, bold, reverse, dim, BRIGHT,
default_colors,
)
class Default(ColorScheme):
progress_bar_color = blue
def use(self, context): # pylint: disable=too-many-branches,too-many-statements
fg, bg, attr = default_colors
if context.reset:
return default_colors
elif context.in_browser:
if context.selected:
attr = reverse
else:
attr = normal
if context.empty or context.error:
bg = red
if context.border:
fg = default
if context.media:
if context.image:
fg = yellow
else:
fg = magenta
if context.container:
fg = red
if context.directory:
attr |= bold
fg = blue
fg += BRIGHT
elif context.executable and not \
any((context.media, context.container,
context.fifo, context.socket)):
attr |= bold
fg = green
fg += BRIGHT
if context.socket:
attr |= bold
fg = magenta
fg += BRIGHT
if context.fifo or context.device:
fg = yellow
if context.device:
attr |= bold
fg += BRIGHT
if context.link:
fg = cyan if context.good else magenta
if context.tag_marker and not context.selected:
attr |= bold
if fg in (red, magenta):
fg = white
else:
fg = red
fg += BRIGHT
if context.line_number and not context.selected:
fg = default
attr &= ~bold
if not context.selected and (context.cut or context.copied):
attr |= bold
fg = black
fg += BRIGHT
# If the terminal doesn't support bright colors, use dim white
# instead of black.
if BRIGHT == 0:
attr |= dim
fg = white
if context.main_column:
# Doubling up with BRIGHT here causes issues because it's
# additive not idempotent.
if context.selected:
attr |= bold
if context.marked:
attr |= bold
fg = yellow
if context.badinfo:
if attr & reverse:
bg = magenta
else:
fg = magenta
if context.inactive_pane:
fg = cyan
elif context.in_titlebar:
if context.hostname:
fg = red if context.bad else green
elif context.directory:
fg = blue
elif context.tab:
if context.good:
bg = green
elif context.link:
fg = cyan
attr |= bold
elif context.in_statusbar:
if context.permissions:
if context.good:
fg = cyan
elif context.bad:
fg = magenta
if context.marked:
attr |= bold | reverse
fg = yellow
fg += BRIGHT
if context.frozen:
attr |= bold | reverse
fg = cyan
fg += BRIGHT
if context.message:
if context.bad:
attr |= bold
fg = red
fg += BRIGHT
if context.loaded:
bg = self.progress_bar_color
if context.vcsinfo:
fg = blue
attr &= ~bold
if context.vcscommit:
fg = yellow
attr &= ~bold
if context.vcsdate:
fg = cyan
attr &= ~bold
if context.text:
if context.highlight:
attr |= reverse
if context.in_taskview:
if context.title:
fg = blue
if context.selected:
attr |= reverse
if context.loaded:
if context.selected:
fg = self.progress_bar_color
else:
bg = self.progress_bar_color
if context.vcsfile and not context.selected:
attr &= ~bold
if context.vcsconflict:
fg = magenta
elif context.vcsuntracked:
fg = cyan
elif context.vcschanged:
fg = red
elif context.vcsunknown:
fg = red
elif context.vcsstaged:
fg = green
elif context.vcssync:
fg = green
elif context.vcsignored:
fg = default
elif context.vcsremote and not context.selected:
attr &= ~bold
if context.vcssync or context.vcsnone:
fg = green
elif context.vcsbehind:
fg = red
elif context.vcsahead:
fg = blue
elif context.vcsdiverged:
fg = magenta
elif context.vcsunknown:
fg = red
return fg, bg, attr
| 5,864 | Python | .py | 169 | 19.674556 | 84 | 0.457908 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
750 | jungle.py | ranger_ranger/ranger/colorschemes/jungle.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from ranger.colorschemes.default import Default
from ranger.gui.color import green, red, blue, bold
class Scheme(Default):
progress_bar_color = green
def use(self, context):
fg, bg, attr = Default.use(self, context)
if context.directory and not context.marked and not context.link \
and not context.inactive_pane:
fg = self.progress_bar_color
if context.line_number and not context.selected:
fg = self.progress_bar_color
attr &= ~bold
if context.in_titlebar and context.hostname:
fg = red if context.bad else blue
return fg, bg, attr
| 845 | Python | .py | 18 | 39.222222 | 74 | 0.679707 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
751 | __init__.py | ranger_ranger/ranger/colorschemes/__init__.py | """Colorschemes are required to be located here or in confdir/colorschemes/"""
| 79 | Python | .py | 1 | 78 | 78 | 0.782051 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
752 | solarized.py | ranger_ranger/ranger/colorschemes/solarized.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# Author: Joseph Tannhuber <[email protected]>, 2013
# Solarized like colorscheme, similar to solarized-dircolors
# from https://github.com/seebi/dircolors-solarized.
# This is a modification of Roman Zimbelmann's default colorscheme.
from __future__ import (absolute_import, division, print_function)
from ranger.gui.colorscheme import ColorScheme
from ranger.gui.color import (
cyan, magenta, red, white, default,
normal, bold, reverse,
default_colors,
)
class Solarized(ColorScheme):
progress_bar_color = 33
def use(self, context): # pylint: disable=too-many-branches,too-many-statements
fg, bg, attr = default_colors
if context.reset:
return default_colors
elif context.in_browser:
fg = 244
if context.selected:
attr = reverse
else:
attr = normal
if context.empty or context.error:
fg = 235
bg = 160
if context.border:
fg = default
if context.media:
if context.image:
fg = 136
else:
fg = 166
if context.container:
fg = 61
if context.directory:
fg = 33
elif context.executable and not \
any((context.media, context.container,
context.fifo, context.socket)):
fg = 64
attr |= bold
if context.socket:
fg = 136
bg = 230
attr |= bold
if context.fifo:
fg = 136
bg = 230
attr |= bold
if context.device:
fg = 244
bg = 230
attr |= bold
if context.link:
fg = 37 if context.good else 160
attr |= bold
if context.bad:
bg = 235
if context.tag_marker and not context.selected:
attr |= bold
if fg in (red, magenta):
fg = white
else:
fg = red
if not context.selected and (context.cut or context.copied):
fg = 234
attr |= bold
if context.main_column:
if context.selected:
attr |= bold
if context.marked:
attr |= bold
bg = 237
if context.badinfo:
if attr & reverse:
bg = magenta
else:
fg = magenta
if context.inactive_pane:
fg = 241
elif context.in_titlebar:
attr |= bold
if context.hostname:
fg = 16 if context.bad else 255
if context.bad:
bg = 166
elif context.directory:
fg = 33
elif context.tab:
fg = 47 if context.good else 33
bg = 239
elif context.link:
fg = cyan
elif context.in_statusbar:
if context.permissions:
if context.good:
fg = 93
elif context.bad:
fg = 160
bg = 235
if context.marked:
attr |= bold | reverse
fg = 237
bg = 47
if context.message:
if context.bad:
attr |= bold
fg = 160
bg = 235
if context.loaded:
bg = self.progress_bar_color
if context.text:
if context.highlight:
attr |= reverse
if context.in_taskview:
if context.title:
fg = 93
if context.selected:
attr |= reverse
if context.loaded:
if context.selected:
fg = self.progress_bar_color
else:
bg = self.progress_bar_color
return fg, bg, attr
| 4,361 | Python | .py | 128 | 19.601563 | 84 | 0.462304 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
753 | snow.py | ranger_ranger/ranger/colorschemes/snow.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
from ranger.gui.colorscheme import ColorScheme
from ranger.gui.color import default_colors, reverse, bold, BRIGHT
class Snow(ColorScheme):
def use(self, context):
fg, bg, attr = default_colors
if context.reset:
pass
elif context.in_browser:
if context.selected:
attr = reverse
if context.directory:
attr |= bold
fg += BRIGHT
if context.line_number and not context.selected:
attr |= bold
fg += BRIGHT
elif context.highlight:
attr |= reverse
elif context.in_titlebar and context.tab and context.good:
attr |= reverse
elif context.in_statusbar:
if context.loaded:
attr |= reverse
if context.marked:
attr |= reverse
elif context.in_taskview:
if context.selected:
attr |= bold
fg += BRIGHT
if context.loaded:
attr |= reverse
return fg, bg, attr
| 1,290 | Python | .py | 35 | 25.571429 | 66 | 0.570394 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
754 | loader.py | ranger_ranger/ranger/core/loader.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import errno
import math
import os.path
import select
from collections import deque
from io import open
from subprocess import Popen, PIPE
from time import time, sleep
try:
import chardet # pylint: disable=import-error
HAVE_CHARDET = True
except ImportError:
HAVE_CHARDET = False
from ranger import PY3
from ranger.core.shared import FileManagerAware
from ranger.ext.human_readable import human_readable
from ranger.ext.safe_path import get_safe_path
from ranger.ext.signals import SignalDispatcher
class Loadable(object):
paused = False
progressbar_supported = False
def __init__(self, gen, descr):
self.load_generator = gen
self.description = descr
self.percent = 0
def get_description(self):
return self.description
def pause(self):
self.paused = True
def unpause(self):
try:
del self.paused
except AttributeError:
pass
def destroy(self):
pass
class CopyLoader(Loadable, FileManagerAware): # pylint: disable=too-many-instance-attributes
progressbar_supported = True
def __init__(self, copy_buffer, do_cut=False, overwrite=False, dest=None,
make_safe_path=get_safe_path):
self.copy_buffer = tuple(copy_buffer)
self.do_cut = do_cut
self.original_copy_buffer = copy_buffer
self.original_path = dest if dest is not None else self.fm.thistab.path
self.overwrite = overwrite
self.make_safe_path = make_safe_path
self.percent = 0
if self.copy_buffer:
self.one_file = self.copy_buffer[0]
Loadable.__init__(self, self.generate(), 'Calculating size...')
def _calculate_size(self, step):
from os.path import join
size = 0
stack = [fobj.path for fobj in self.copy_buffer]
while stack:
fname = stack.pop()
if os.path.islink(fname):
continue
if os.path.isdir(fname):
stack.extend([join(fname, item) for item in os.listdir(fname)])
else:
try:
fstat = os.stat(fname)
except OSError:
continue
size += max(step, math.ceil(fstat.st_size / step) * step)
return size
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)
new_path = path.replace(
fobj.path,
os.path.join(self.original_path, fobj.basename))
self.fm.tags.tags[new_path] = tag
self.fm.tags.dump()
n = 0
for n in shutil_g.move(src=fobj.path, dst=self.original_path,
overwrite=self.overwrite,
make_safe_path=self.make_safe_path):
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,
make_safe_path=self.make_safe_path,
):
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,
make_safe_path=self.make_safe_path):
self.percent = ((done + n) / size) * 100.
yield
done += n
cwd = self.fm.get_directory(self.original_path)
cwd.load_content()
class CommandLoader( # pylint: disable=too-many-instance-attributes
Loadable, SignalDispatcher, FileManagerAware):
"""Run an external command with the loader.
Output from stderr will be reported. Ensure that the process doesn't
ever ask for input, otherwise the loader will be blocked until this
object is removed from the queue (type ^C in ranger)
"""
finished = False
process = None
def __init__(self, args, descr, # pylint: disable=too-many-arguments
silent=False, read=False, input=None, # pylint: disable=redefined-builtin
kill_on_pause=False, popenArgs=None):
SignalDispatcher.__init__(self)
Loadable.__init__(self, self.generate(), descr)
self.args = args
self.silent = silent
self.read = read
self.stdout_buffer = ""
self.input = input
self.kill_on_pause = kill_on_pause
self.popenArgs = popenArgs # pylint: disable=invalid-name
def generate(self):
# pylint: disable=too-many-branches,too-many-statements
# TODO: Check whether we can afford to wait for processes and use a
# with-statement for Popen.
# pylint: disable=consider-using-with
popenargs = {} if self.popenArgs is None else self.popenArgs
popenargs['stdout'] = popenargs['stderr'] = PIPE
popenargs['stdin'] = (
PIPE if self.input else open(os.devnull, 'r', encoding="utf-8")
)
self.process = process = Popen(self.args, **popenargs)
self.signal_emit('before', process=process, loader=self)
if self.input:
if PY3:
import io
stdin = io.TextIOWrapper(process.stdin)
else:
stdin = process.stdin
try:
stdin.write(self.input)
except IOError as ex:
if ex.errno not in (errno.EPIPE, errno.EINVAL):
raise
stdin.close()
if self.silent and not self.read: # pylint: disable=too-many-nested-blocks
while process.poll() is None:
yield
if self.finished:
break
sleep(0.03)
else:
selectlist = []
if self.read:
selectlist.append(process.stdout)
if not self.silent:
selectlist.append(process.stderr)
read_stdout = None
while process.poll() is None:
yield
if self.finished:
break
try:
robjs, _, _ = select.select(selectlist, [], [], 0.03)
if robjs:
robjs = robjs[0]
if robjs == process.stderr:
read = robjs.readline()
if PY3:
read = safe_decode(read)
if read:
self.fm.notify(read, bad=True)
elif robjs == process.stdout:
read = robjs.read(512)
if read:
if read_stdout is None:
read_stdout = read
else:
read_stdout += read
except select.error:
sleep(0.03)
if not self.silent:
for line in process.stderr:
if PY3:
line = safe_decode(line)
self.fm.notify(line, bad=True)
if self.read:
read = process.stdout.read()
if read:
read_stdout += read
if read_stdout:
if PY3:
read_stdout = safe_decode(read_stdout)
self.stdout_buffer += read_stdout
self.finished = True
self.signal_emit('after', process=process, loader=self)
def pause(self):
if not self.finished and not self.paused:
if self.kill_on_pause:
self.finished = True
try:
self.process.kill()
except OSError:
# probably a race condition where the process finished
# between the last poll()ing and this point.
pass
return
try:
self.process.send_signal(20)
except OSError:
pass
Loadable.pause(self)
self.signal_emit('pause', process=self.process, loader=self)
def unpause(self):
if not self.finished and self.paused:
try:
self.process.send_signal(18)
except OSError:
pass
Loadable.unpause(self)
self.signal_emit('unpause', process=self.process, loader=self)
def destroy(self):
self.signal_emit('destroy', process=self.process, loader=self)
if self.process:
try:
self.process.kill()
except OSError:
pass
def safe_decode(string):
try:
return string.decode("utf-8")
except UnicodeDecodeError:
if HAVE_CHARDET:
encoding = chardet.detect(string)["encoding"]
if encoding:
return string.decode(encoding, 'ignore')
return ""
class Loader(FileManagerAware):
"""
The Manager of 'Loadable' objects, referenced as fm.loader
"""
seconds_of_work_time = 0.03
throbber_chars = r'/-\|'
throbber_paused = '#'
paused = False
def __init__(self):
self.queue = deque()
self.item = None
self.load_generator = None
self.throbber_status = 0
self.rotate()
self.old_item = None
self.status = None
def rotate(self):
"""Rotate the throbber"""
# TODO: move all throbber logic to UI
self.throbber_status = \
(self.throbber_status + 1) % len(self.throbber_chars)
self.status = self.throbber_chars[self.throbber_status]
def add(self, obj, append=False):
"""Add an object to the queue.
It should have a load_generator method.
If the argument "append" is True, the queued object will be processed
last, not first.
"""
while obj in self.queue:
self.queue.remove(obj)
if append:
self.queue.append(obj)
else:
self.queue.appendleft(obj)
self.fm.signal_emit("loader.before", loadable=obj, fm=self.fm)
if self.paused:
obj.pause()
else:
obj.unpause()
def move(self, pos_src, pos_dest):
try:
item = self.queue[pos_src]
except IndexError:
return
del self.queue[pos_src]
if pos_dest == 0:
self.queue.appendleft(item)
if pos_src != 0:
self.queue[1].pause()
elif pos_dest == -1:
self.queue.append(item)
else:
raise NotImplementedError
def remove(self, item=None, index=None):
if item is not None and index is None:
for i, test in enumerate(self.queue):
if test == item:
index = i
break
else:
return
if index is not None:
if item is None:
item = self.queue[index]
if hasattr(item, 'unload'):
item.unload()
self.fm.signal_emit("loader.destroy", loadable=item, fm=self.fm)
item.destroy()
del self.queue[index]
if item.progressbar_supported:
self.fm.ui.status.request_redraw()
def pause(self, state):
"""Change the pause-state to 1 (pause), 0 (no pause) or -1 (toggle)"""
if state == -1:
state = not self.paused
elif state == self.paused:
return
self.paused = state
if not self.queue:
return
if state:
self.queue[0].pause()
else:
self.queue[0].unpause()
def work(self):
"""Load items from the queue if there are any.
Stop after approximately self.seconds_of_work_time.
"""
if self.paused:
self.status = self.throbber_paused
return
while True:
# get the first item with a proper load_generator
try:
item = self.queue[0]
if item.load_generator is None:
self.queue.popleft()
else:
break
except IndexError:
return
item.unpause()
self.rotate()
if item != self.old_item:
if self.old_item:
self.old_item.pause()
self.old_item = item
item.unpause()
end_time = time() + self.seconds_of_work_time
while time() < end_time:
try:
next(item.load_generator)
except StopIteration:
self._remove_current_process(item)
break
except Exception as ex: # pylint: disable=broad-except
self.fm.notify(
'Loader work process failed: {0} (Percent: {1})'.format(
item.description, item.percent),
bad=True,
exception=ex,
)
self.old_item = None
self._remove_current_process(item)
break
else:
if item.progressbar_supported:
self.fm.ui.status.request_redraw()
def _remove_current_process(self, item):
item.load_generator = None
self.queue.remove(item)
self.fm.signal_emit("loader.after", loadable=item, fm=self.fm)
if item.progressbar_supported:
self.fm.ui.status.request_redraw()
def has_work(self):
"""Is there anything to load?"""
return bool(self.queue)
def destroy(self):
while self.queue:
self.queue.pop().destroy()
| 15,792 | Python | .py | 407 | 25.609337 | 93 | 0.525307 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
755 | runner.py | ranger_ranger/ranger/core/runner.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""This module is an abstract layer over subprocess.Popen
It gives you highlevel control about how processes are run.
Example:
run = Runner(logfunc=print)
run('sleep 2', wait=True) # waits until the process exists
run(['ls', '--help'], flags='p') # pipes output to pager
run() # prints an error message
List of allowed flags:
s: silent mode. output will be discarded.
f: fork the process.
p: redirect output to the pager
c: run only the current file (not handled here)
w: wait for enter-press afterwards
r: run application with root privilege (requires sudo)
t: run application in a new terminal window
(An uppercase key negates the respective lower case flag)
"""
from __future__ import (absolute_import, division, print_function)
import logging
import os
import sys
from io import open
from subprocess import Popen, PIPE, STDOUT
from ranger.ext.get_executables import get_executables, get_term
from ranger.ext.popen_forked import Popen_forked
LOG = logging.getLogger(__name__)
# TODO: Remove unused parts of runner.py
# ALLOWED_FLAGS = 'sdpwcrtSDPWCRT'
ALLOWED_FLAGS = 'cfrtCFRT'
def press_enter():
"""Wait for an ENTER-press"""
sys.stdout.write("Press ENTER to continue")
try:
waitfnc = raw_input
except NameError:
# "raw_input" not available in python3
waitfnc = input
waitfnc()
class Context(object): # pylint: disable=too-many-instance-attributes
"""A context object contains data on how to run a process.
The attributes are:
action -- a string with a command or a list of arguments for
the Popen call.
app -- the name of the app function. ("vim" for app_vim.)
app is used to get an action if the user didn't specify one.
mode -- a number, mainly used in determining the action in app_xyz()
flags -- a string with flags which change the way programs are run
files -- a list containing files, mainly used in app_xyz
file -- an arbitrary file from that list (or None)
fm -- the filemanager instance
wait -- boolean, wait for the end or execute programs in parallel?
popen_kws -- keyword arguments which are directly passed to Popen
"""
def __init__( # pylint: disable=redefined-builtin,too-many-arguments
self, action=None, app=None, mode=None, flags=None,
files=None, file=None, fm=None, wait=None, popen_kws=None):
self.action = action
self.app = app
self.mode = mode
self.flags = flags
self.files = files
self.file = file
self.fm = fm
self.wait = wait
self.popen_kws = popen_kws
@property
def filepaths(self):
try:
return [f.path for f in self.files]
except AttributeError:
return []
def __iter__(self):
"""Iterate over file paths"""
for item in self.filepaths:
yield item
def squash_flags(self):
"""Remove duplicates and lowercase counterparts of uppercase flags"""
for flag in self.flags:
if ord(flag) <= 90:
bad = flag + flag.lower()
self.flags = ''.join(c for c in self.flags if c not in bad)
class Runner(object): # pylint: disable=too-few-public-methods
def __init__(self, ui=None, logfunc=None, fm=None):
self.ui = ui
self.fm = fm
self.logfunc = logfunc
self.zombies = set()
def _log(self, text):
try:
self.logfunc(text)
except TypeError:
pass
return False
def _activate_ui(self, boolean):
if self.ui is not None:
if boolean:
try:
self.ui.initialize()
except Exception as ex: # pylint: disable=broad-except
self._log("Failed to initialize UI")
LOG.exception(ex)
else:
try:
self.ui.suspend()
except Exception as ex: # pylint: disable=broad-except
self._log("Failed to suspend UI")
LOG.exception(ex)
def __call__(
# pylint: disable=too-many-branches,too-many-statements
# pylint: disable=too-many-arguments,too-many-locals
self, action=None, try_app_first=False,
app='default', files=None, mode=0,
flags='', wait=True, **popen_kws):
"""Run the application in the way specified by the options.
Returns False if nothing can be done, None if there was an error,
otherwise the process object returned by Popen().
This function tries to find an action if none is defined.
"""
# Find an action if none was supplied by
# creating a Context object and passing it to
# an Application object.
context = Context(app=app, files=files, mode=mode, fm=self.fm,
flags=flags, wait=wait, popen_kws=popen_kws,
file=files and files[0] or None)
if action is None:
return self._log("No way of determining the action!")
# Preconditions
context.squash_flags()
popen_kws = context.popen_kws # shortcut
toggle_ui = True
pipe_output = False
wait_for_enter = False
devnull = None
if 'shell' not in popen_kws:
popen_kws['shell'] = isinstance(action, str)
# Set default shell for Popen
if popen_kws['shell']:
# This doesn't work with fish, see #300
if 'fish' not in os.environ['SHELL']:
popen_kws['executable'] = os.environ['SHELL']
if 'stdout' not in popen_kws:
popen_kws['stdout'] = sys.stdout
if 'stderr' not in popen_kws:
popen_kws['stderr'] = sys.stderr
# Evaluate the flags to determine keywords
# for Popen() and other variables
if 'p' in context.flags:
popen_kws['stdout'] = PIPE
popen_kws['stderr'] = STDOUT
toggle_ui = False
pipe_output = True
context.wait = False
if 's' in context.flags:
# Using a with-statement for these is inconvenient.
# pylint: disable=consider-using-with
devnull_writable = open(os.devnull, 'w', encoding="utf-8")
devnull_readable = open(os.devnull, 'r', encoding="utf-8")
for key in ('stdout', 'stderr'):
popen_kws[key] = devnull_writable
toggle_ui = False
popen_kws['stdin'] = devnull_readable
if 'f' in context.flags:
toggle_ui = False
context.wait = False
if 'w' in context.flags:
if not pipe_output and context.wait: # <-- sanity check
wait_for_enter = True
if 'r' in context.flags:
# TODO: make 'r' flag work with pipes
if 'sudo' not in get_executables():
return self._log("Can not run with 'r' flag, sudo is not installed!")
f_flag = ('f' in context.flags)
if isinstance(action, str):
action = 'sudo ' + (f_flag and '-b ' or '') + action
else:
action = ['sudo'] + (f_flag and ['-b'] or []) + action
toggle_ui = True
context.wait = True
if 't' in context.flags:
if not ('WAYLAND_DISPLAY' in os.environ
or sys.platform == 'darwin'
or 'DISPLAY' in os.environ):
return self._log("Can not run with 't' flag, no display found!")
term = get_term()
if isinstance(action, str):
action = term + ' -e ' + action
else:
action = [term, '-e'] + action
toggle_ui = False
context.wait = False
popen_kws['args'] = action
# Finally, run it
if toggle_ui:
self._activate_ui(False)
error = None
process = None
try:
self.fm.signal_emit('runner.execute.before',
popen_kws=popen_kws, context=context)
try:
if 'f' in context.flags and 'r' not in context.flags:
# This can fail and return False if os.fork() is not
# supported, but we assume it is, since curses is used.
# pylint: disable=consider-using-with
Popen_forked(**popen_kws)
else:
process = Popen(**popen_kws)
except OSError as ex:
error = ex
self._log("Failed to run: %s\n%s" % (str(action), str(ex)))
else:
if context.wait:
process.wait()
elif process:
self.zombies.add(process)
if wait_for_enter:
press_enter()
finally:
self.fm.signal_emit('runner.execute.after',
popen_kws=popen_kws, context=context, error=error)
if devnull:
devnull.close()
if toggle_ui:
self._activate_ui(True)
if pipe_output and process:
return self(action='less', app='pager', # pylint: disable=lost-exception
try_app_first=True, stdin=process.stdout)
return process # pylint: disable=lost-exception
| 9,641 | Python | .py | 230 | 31.182609 | 89 | 0.574082 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
756 | fm.py | ranger_ranger/ranger/core/fm.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The File Manager, putting the pieces together"""
from __future__ import (absolute_import, division, print_function)
import mimetypes
import os.path
import pwd
import socket
import stat
import sys
from collections import deque
from io import open
from time import time
import ranger.api
from ranger.container import settings
from ranger.container.bookmarks import Bookmarks
from ranger.container.directory import Directory
from ranger.container.tags import Tags, TagsDummy
from ranger.core.actions import Actions
from ranger.core.loader import Loader
from ranger.core.metadata import MetadataManager
from ranger.core.runner import Runner
from ranger.core.tab import Tab
from ranger.ext import logutils
from ranger.ext.img_display import get_image_displayer
from ranger.ext.rifle import Rifle
from ranger.ext.signals import SignalDispatcher
from ranger.gui.ui import UI
class FM(Actions, # pylint: disable=too-many-instance-attributes
SignalDispatcher):
input_blocked = False
input_blocked_until = 0
mode = 'normal' # either 'normal' or 'visual'.
search_method = 'ctime'
_previous_selection = None
_visual_reverse = False
_visual_pos_start = None
_visual_move_cycles = None
def __init__(self, ui=None, bookmarks=None, tags=None, paths=None):
"""Initialize FM."""
Actions.__init__(self)
SignalDispatcher.__init__(self)
self.ui = ui if ui is not None else UI()
self.start_paths = paths if paths is not None else ['.']
self.directories = {}
self.bookmarks = bookmarks
self.current_tab = 1
self.tabs = {}
self.tags = tags
self.restorable_tabs = deque([], ranger.MAX_RESTORABLE_TABS)
self.previews = {}
self.default_linemodes = deque()
self.loader = Loader()
self.copy_buffer = set()
self.do_cut = False
self.metadata = MetadataManager()
self.image_displayer = None
self.run = None
self.rifle = None
self.thistab = None
try:
self.username = pwd.getpwuid(os.geteuid()).pw_name
except KeyError:
self.username = 'uid:' + str(os.geteuid())
self.hostname = socket.gethostname()
self.home_path = os.path.expanduser('~')
if not mimetypes.inited:
extra_files = [self.relpath('data/mime.types'), os.path.expanduser("~/.mime.types")]
mimetypes.init(mimetypes.knownfiles + extra_files)
self.mimetypes = mimetypes
def initialize(self): # pylint: disable=too-many-statements
"""If ui/bookmarks are None, they will be initialized here."""
self.tabs = dict((n + 1, Tab(path)) for n, path in enumerate(self.start_paths))
tab_list = self.get_tab_list()
if tab_list:
self.current_tab = tab_list[0]
self.thistab = self.tabs[self.current_tab]
else:
self.current_tab = 1
self.tabs[self.current_tab] = self.thistab = Tab('.')
if not ranger.args.clean and os.path.isfile(self.confpath('rifle.conf')):
rifleconf = self.confpath('rifle.conf')
else:
rifleconf = self.relpath('config/rifle.conf')
self.rifle = Rifle(rifleconf)
self.rifle.reload_config()
def set_image_displayer():
if self.image_displayer:
self.image_displayer.quit()
self.image_displayer = get_image_displayer(self.settings.preview_images_method)
set_image_displayer()
self.settings.signal_bind('setopt.preview_images_method', set_image_displayer,
priority=settings.SIGNAL_PRIORITY_AFTER_SYNC)
self.settings.signal_bind(
'setopt.preview_images',
lambda signal: signal.fm.previews.clear(),
)
if ranger.args.clean:
self.tags = TagsDummy("")
elif self.tags is None:
self.tags = Tags(self.datapath('tagged'))
if self.bookmarks is None:
if ranger.args.clean:
bookmarkfile = None
else:
bookmarkfile = self.datapath('bookmarks')
self.bookmarks = Bookmarks(
bookmarkfile=bookmarkfile,
bookmarktype=Directory,
autosave=self.settings.autosave_bookmarks)
self.bookmarks.load()
self.bookmarks.enable_saving_backtick_bookmark(
self.settings.save_backtick_bookmark)
self.ui.setup_curses()
self.ui.initialize()
self.rifle.hook_before_executing = lambda a, b, flags: \
self.ui.suspend() if 'f' not in flags else None
self.rifle.hook_after_executing = lambda a, b, flags: \
self.ui.initialize() if 'f' not in flags else None
self.rifle.hook_logger = self.notify
old_preprocessing_hook = self.rifle.hook_command_preprocessing
# This hook allows image viewers to open all images in the current
# directory, keeping the order of files the same as in ranger.
# The requirements to use it are:
# 1. set open_all_images to true
# 2. ensure no files are marked
# 3. call rifle with a command that starts with "sxiv " or similarly
# behaved image viewers
def sxiv_workaround_hook(command):
import re
from ranger.ext.shell_escape import shell_quote
if self.settings.open_all_images and \
not self.thisdir.marked_items and \
re.match(r'^(feh|n?sxiv|imv|pqiv) ', command):
images = [f.relative_path for f in self.thisdir.files if f.image]
escaped_filenames = " ".join(shell_quote(f) for f in images if "\x00" not in f)
if images and self.thisfile.relative_path in images and \
"$@" in command:
new_command = None
if command[0:5] == 'sxiv ' or command[0:6] == 'nsxiv ':
number = images.index(self.thisfile.relative_path) + 1
new_command = command.replace("sxiv ", "sxiv -n %d " % number, 1)
if command[0:4] == 'feh ':
new_command = command.replace(
"feh ",
"feh --start-at %s " % shell_quote(self.thisfile.relative_path),
1,
)
if command[0:4] == 'imv ':
number = images.index(self.thisfile.relative_path) + 1
new_command = command.replace("imv ", "imv -n %d " % number, 1)
if command[0:5] == 'pqiv ':
number = images.index(self.thisfile.relative_path)
new_command = command.replace(
"pqiv ", "pqiv --action \"goto_file_byindex(%d)\" " % number, 1)
if new_command:
command = "set -- %s; %s" % (escaped_filenames, new_command)
return old_preprocessing_hook(command)
self.rifle.hook_command_preprocessing = sxiv_workaround_hook
def mylogfunc(text):
self.notify(text, bad=True)
self.run = Runner(ui=self.ui, logfunc=mylogfunc, fm=self)
self.settings.signal_bind(
'setopt.metadata_deep_search',
lambda signal: setattr(signal.fm.metadata, 'deep_search', signal.value)
)
self.settings.signal_bind(
'setopt.save_backtick_bookmark',
lambda signal: signal.fm.bookmarks.enable_saving_backtick_bookmark(signal.value)
)
def destroy(self):
debug = ranger.args.debug
if self.ui:
try:
self.ui.destroy()
except Exception: # pylint: disable=broad-except
if debug:
raise
if self.loader:
try:
self.loader.destroy()
except Exception: # pylint: disable=broad-except
if debug:
raise
@staticmethod
def get_log():
"""Return the current log
The log is returned as a generator over its entries' lines
"""
for entry in logutils.QUEUE:
for line in entry.splitlines():
yield line
def _get_thisfile(self):
return self.thistab.thisfile
def _set_thisfile(self, obj):
self.thistab.thisfile = obj
def _get_thisdir(self):
return self.thistab.thisdir
def _set_thisdir(self, obj):
self.thistab.thisdir = obj
thisfile = property(_get_thisfile, _set_thisfile)
thisdir = property(_get_thisdir, _set_thisdir)
def block_input(self, sec=0):
self.input_blocked = sec != 0
self.input_blocked_until = time() + sec
def input_is_blocked(self):
if self.input_blocked and time() > self.input_blocked_until:
self.input_blocked = False
return self.input_blocked
def copy_config_files(self, which):
if ranger.args.clean:
sys.stderr.write("refusing to copy config files in clean mode\n")
return
import shutil
from errno import EEXIST
def copy(src, dest):
if os.path.exists(self.confpath(dest)):
sys.stderr.write("already exists: %s\n" % self.confpath(dest))
else:
sys.stderr.write("creating: %s\n" % self.confpath(dest))
try:
os.makedirs(ranger.args.confdir)
except OSError as err:
if err.errno != EEXIST: # EEXIST means it already exists
print("This configuration directory could not be created:")
print(ranger.args.confdir)
print("To run ranger without the need for configuration")
print("files, use the --clean option.")
raise SystemExit
try:
shutil.copy(self.relpath(src), self.confpath(dest))
except OSError as ex:
sys.stderr.write(" ERROR: %s\n" % str(ex))
if which in ('rifle', 'all'):
copy('config/rifle.conf', 'rifle.conf')
if which in ('commands', 'all'):
copy('config/commands_sample.py', 'commands.py')
if which in ('commands_full', 'all'):
copy('config/commands.py', 'commands_full.py')
if which in ('rc', 'all'):
copy('config/rc.conf', 'rc.conf')
if which in ('scope', 'all'):
copy('data/scope.sh', 'scope.sh')
os.chmod(self.confpath('scope.sh'),
os.stat(self.confpath('scope.sh')).st_mode | stat.S_IXUSR)
if which in ('all', 'rifle', 'scope', 'commands', 'commands_full', 'rc'):
sys.stderr.write("\n> Please note that configuration files may "
"change as ranger evolves.\n It's completely up to you to "
"keep them up to date.\n")
if os.environ.get('RANGER_LOAD_DEFAULT_RC', 'TRUE').upper() != 'FALSE':
sys.stderr.write("\n> To stop ranger from loading "
"\033[1mboth\033[0m the default and your custom rc.conf,\n"
" please set the environment variable "
"\033[1mRANGER_LOAD_DEFAULT_RC\033[0m to "
"\033[1mFALSE\033[0m.\n")
else:
sys.stderr.write("Unknown config file `%s'\n" % which)
def confpath(self, *paths):
"""returns path to ranger's configuration directory"""
if ranger.args.clean:
self.notify("Accessed configuration directory in clean mode", bad=True)
return None
return os.path.join(ranger.args.confdir, *paths)
def datapath(self, *paths):
"""returns path to ranger's data directory"""
if ranger.args.clean:
self.notify("Accessed data directory in clean mode", bad=True)
return None
path_compat = self.confpath(*paths) # COMPAT
if os.path.exists(path_compat):
return path_compat
return os.path.join(ranger.args.datadir, *paths)
@staticmethod
def relpath(*paths):
"""returns the path relative to rangers library directory"""
return os.path.join(ranger.RANGERDIR, *paths)
def get_directory(self, path, **dir_kwargs):
"""Get the directory object at the given path"""
path = os.path.abspath(path)
try:
return self.directories[path]
except KeyError:
obj = Directory(path, **dir_kwargs)
self.directories[path] = obj
return obj
@staticmethod
def group_paths_by_dirname(paths):
"""
Groups the paths into a dictionary with their dirnames as keys and a set of
basenames as entries.
"""
groups = {}
for path in paths:
abspath = os.path.abspath(os.path.expanduser(path))
dirname, basename = os.path.split(abspath)
groups.setdefault(dirname, set()).add(basename)
return groups
def get_filesystem_objects(self, paths):
"""
Find FileSystemObjects corresponding to the paths if they are already in
memory and load those that are not.
"""
result = []
# Grouping the files by dirname avoids the potentially quadratic running time of doing
# a linear search in the directory for each entry name that is supposed to be deleted.
groups = self.group_paths_by_dirname(paths)
for dirname, basenames in groups.items():
directory = self.fm.get_directory(dirname)
directory.load_content_if_outdated()
for entry in directory.files_all:
if entry.basename in basenames:
result.append(entry)
basenames.remove(entry.basename)
if basenames != set():
# Abort the operation with an error message if there are entries
# that weren't found.
names = ', '.join(basenames)
self.fm.notify('Error: No such file or directory: {0}'.format(
names), bad=True)
return None
return result
def garbage_collect(
self, age,
tabs=None): # tabs=None is for COMPATibility pylint: disable=unused-argument
"""Delete unused directory objects"""
for key in tuple(self.directories):
value = self.directories[key]
if age != -1:
if not value.is_older_than(age) \
or any(value in tab.pathway for tab in self.tabs.values()):
continue
del self.directories[key]
if value.is_directory:
value.files = None
self.settings.signal_garbage_collect()
self.signal_garbage_collect()
def loop(self):
"""The main loop of ranger.
It consists of:
1. reloading bookmarks if outdated
2. letting the loader work
3. drawing and finalizing ui
4. reading and handling user input
5. after X loops: collecting unused directory objects
"""
self.enter_dir(self.thistab.path)
# for faster lookup:
ui = self.ui
throbber = ui.throbber
loader = self.loader
zombies = self.run.zombies
ranger.api.hook_ready(self)
try: # pylint: disable=too-many-nested-blocks
while True:
loader.work()
if loader.has_work():
throbber(loader.status)
else:
throbber(remove=True)
ui.redraw()
ui.set_load_mode(not loader.paused and loader.has_work())
ui.draw_images()
ui.handle_input()
if zombies:
for zombie in tuple(zombies):
if zombie.poll() is not None:
zombies.remove(zombie)
# gc_tick += 1
# if gc_tick > ranger.TICKS_BEFORE_COLLECTING_GARBAGE:
# gc_tick = 0
# self.garbage_collect(ranger.TIME_BEFORE_FILE_BECOMES_GARBAGE)
except KeyboardInterrupt:
# this only happens in --debug mode. By default, interrupts
# are caught in curses_interrupt_handler
raise SystemExit
finally:
self.image_displayer.quit()
if ranger.args.choosedir and self.thisdir and self.thisdir.path:
# XXX: UnicodeEncodeError: 'utf-8' codec can't encode character
# '\udcf6' in position 42: surrogates not allowed
with open(ranger.args.choosedir, 'w', encoding="utf-8") as fobj:
fobj.write(self.thisdir.path)
self.bookmarks.remember(self.thisdir)
self.bookmarks.save()
# Save tabs
if not ranger.args.clean and self.settings.save_tabs_on_exit and len(self.tabs) > 1:
with open(self.datapath('tabs'), 'a', encoding="utf-8") as fobj:
# Don't save active tab since launching ranger changes the active tab
fobj.write('\0'.join(v.path for t, v in self.tabs.items())
+ '\0\0')
| 17,742 | Python | .py | 390 | 33.215385 | 96 | 0.577428 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
757 | metadata.py | ranger_ranger/ranger/core/metadata.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""
A Metadata Manager that reads information about files from a json database.
The database is contained in a local .metadata.json file.
"""
# TODO: Better error handling if a json file can't be decoded
# TODO: Update metadata keys if a file gets renamed/moved
# TODO: A global metadata file, maybe as a replacement for tags
from __future__ import (absolute_import, division, print_function)
import copy
from io import open
from os.path import join, dirname, exists, basename
from ranger.ext.openstruct import DefaultOpenStruct as ostruct
METADATA_FILE_NAME = ".metadata.json"
DEEP_SEARCH_DEFAULT = False
class MetadataManager(object):
def __init__(self):
# metadata_cache maps filenames to dicts containing their metadata
self.metadata_cache = {}
# metafile_cache maps .metadata.json filenames to their entries
self.metafile_cache = {}
self.deep_search = DEEP_SEARCH_DEFAULT
def reset(self):
self.metadata_cache.clear()
self.metafile_cache.clear()
def get_metadata(self, filename):
try:
return ostruct(copy.deepcopy(self.metadata_cache[filename]))
except KeyError:
try:
return ostruct(copy.deepcopy(self._get_entry(filename)))
except KeyError:
return ostruct()
def set_metadata(self, filename, update_dict):
if not self.deep_search:
metafile = next(self._get_metafile_names(filename))
return self._set_metadata_raw(filename, update_dict, metafile)
metafile = self._get_metafile_name(filename)
return self._set_metadata_raw(filename, update_dict, metafile)
def _set_metadata_raw(self, filename, update_dict, metafile):
import json
entries = self._get_metafile_content(metafile)
try:
entry = entries[filename]
except KeyError:
try:
entry = entries[basename(filename)]
except KeyError:
entry = entries[basename(filename)] = {}
entry.update(update_dict)
# Delete key if the value is empty
for key, value in update_dict.items():
if value == "":
del entry[key]
# If file's metadata become empty after an update, remove it entirely
if entry == {}:
try:
del entries[filename]
except KeyError:
try:
del entries[basename(filename)]
except KeyError:
pass
# Full update of the cache, to be on the safe side:
self.metadata_cache[filename] = entry
self.metafile_cache[metafile] = entries
with open(metafile, "w", encoding="utf-8") as fobj:
json.dump(entries, fobj, check_circular=True, indent=2)
def _get_entry(self, filename):
if filename in self.metadata_cache:
return self.metadata_cache[filename]
# Try to find an entry for this file in any of
# the applicable .metadata.json files
for metafile in self._get_metafile_names(filename):
entries = self._get_metafile_content(metafile)
# Check for a direct match:
if filename in entries:
entry = entries[filename]
# Check for a match of the base name:
elif basename(filename) in entries:
entry = entries[basename(filename)]
else:
# No match found, try another entry
continue
self.metadata_cache[filename] = entry
return entry
raise KeyError
def _get_metafile_content(self, metafile):
import json
if metafile in self.metafile_cache:
return self.metafile_cache[metafile]
if exists(metafile):
with open(metafile, "r", encoding="utf-8") as fobj:
try:
entries = json.load(fobj)
except ValueError:
raise ValueError("Failed decoding JSON file %s" % metafile)
self.metafile_cache[metafile] = entries
return entries
return {}
def _get_metafile_names(self, path):
# Iterates through the paths of all .metadata.json files that could
# influence the metadata of the given file.
# When deep_search is deactivated, this only yields the .metadata.json
# file in the same directory as the given file.
base = dirname(path)
yield join(base, METADATA_FILE_NAME)
if self.deep_search:
dirs = base.split("/")[1:]
for i in reversed(range(len(dirs))):
yield join("/" + "/".join(dirs[0:i]), METADATA_FILE_NAME)
def _get_metafile_name(self, filename):
first = None
for metafile in self._get_metafile_names(filename):
if first is None:
first = metafile
entries = self._get_metafile_content(metafile)
if filename in entries or basename(filename) in entries:
return metafile
# _get_metafile_names should return >0 names, but just in case...:
assert first is not None, "failed finding location for .metadata.json"
return first
| 5,407 | Python | .py | 123 | 33.609756 | 79 | 0.62 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
758 | linemode.py | ranger_ranger/ranger/core/linemode.py | # -*- coding: utf-8 -*-
# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# Author: Wojciech Siewierski <[email protected]>, 2015
from __future__ import (absolute_import, division, print_function)
from abc import abstractproperty, abstractmethod
from datetime import datetime
from ranger.ext.abc import ABC
from ranger.ext.human_readable import human_readable, human_readable_time
from ranger.ext import spawn
DEFAULT_LINEMODE = "filename"
class LinemodeBase(ABC):
"""Supplies the file line contents for BrowserColumn.
Attributes:
name (required!) - Name by which the linemode is referred to by the user
uses_metadata - True if metadata should to be loaded for this linemode
required_metadata -
If any of these metadata fields are absent, fall back to
the default linemode
"""
uses_metadata = False
required_metadata = []
name = abstractproperty()
@abstractmethod
def filetitle(self, fobj, metadata):
"""The left-aligned part of the line."""
raise NotImplementedError
def infostring(self, fobj, metadata):
"""The right-aligned part of the line.
If `NotImplementedError' is raised (e.g. this method is just
not implemented in the actual linemode), the caller should
provide its own implementation (which in this case means
displaying the hardlink count of the directories, size of the
files and additionally a symlink marker for symlinks). Useful
because only the caller (BrowserColumn) possesses the data
necessary to display that information.
"""
raise NotImplementedError
class DefaultLinemode(LinemodeBase): # pylint: disable=abstract-method
name = "filename"
def filetitle(self, fobj, metadata):
return fobj.relative_path
class TitleLinemode(LinemodeBase):
name = "metatitle"
uses_metadata = True
required_metadata = ["title"]
def filetitle(self, fobj, metadata):
name = metadata.title
if metadata.year:
return "%s - %s" % (metadata.year, name)
return name
def infostring(self, fobj, metadata):
if metadata.authors:
authorstring = metadata.authors
if ',' in authorstring:
authorstring = authorstring[0:authorstring.find(",")]
return authorstring
return ""
class PermissionsLinemode(LinemodeBase):
name = "permissions"
def filetitle(self, fobj, metadata):
return "%s %s %s %s" % (
fobj.get_permission_string(), fobj.user, fobj.group, fobj.relative_path)
def infostring(self, fobj, metadata):
return ""
class FileInfoLinemode(LinemodeBase):
name = "fileinfo"
def filetitle(self, fobj, metadata):
return fobj.relative_path
def infostring(self, fobj, metadata):
if not fobj.is_directory:
from subprocess import CalledProcessError
try:
fileinfo = spawn.check_output(["file", "-Lb", fobj.path]).strip()
except CalledProcessError:
return "unknown"
return fileinfo
else:
raise NotImplementedError
class MtimeLinemode(LinemodeBase):
name = "mtime"
def filetitle(self, fobj, metadata):
return fobj.relative_path
def infostring(self, fobj, metadata):
if fobj.stat is None:
return '?'
return datetime.fromtimestamp(fobj.stat.st_mtime).strftime("%Y-%m-%d %H:%M")
class SizeMtimeLinemode(LinemodeBase):
name = "sizemtime"
def filetitle(self, fobj, metadata):
return fobj.relative_path
def infostring(self, fobj, metadata):
if fobj.stat is None:
return '?'
if fobj.is_directory and not fobj.cumulative_size_calculated:
if fobj.size is None:
sizestring = ''
else:
sizestring = fobj.size
else:
sizestring = human_readable(fobj.size)
return "%s %s" % (sizestring,
datetime.fromtimestamp(fobj.stat.st_mtime).strftime("%Y-%m-%d %H:%M"))
class HumanReadableMtimeLinemode(LinemodeBase):
name = "humanreadablemtime"
def filetitle(self, fobj, metadata):
return fobj.relative_path
def infostring(self, fobj, metadata):
if fobj.stat is None:
return '?'
return human_readable_time(fobj.stat.st_mtime)
class SizeHumanReadableMtimeLinemode(LinemodeBase):
name = "sizehumanreadablemtime"
def filetitle(self, fobj, metadata):
return fobj.relative_path
def infostring(self, fobj, metadata):
if fobj.stat is None:
return '?'
if fobj.is_directory and not fobj.cumulative_size_calculated:
if fobj.size is None:
sizestring = ''
else:
sizestring = fobj.size
else:
sizestring = human_readable(fobj.size)
return "%s %11s" % (sizestring, human_readable_time(fobj.stat.st_mtime))
| 5,148 | Python | .py | 126 | 32.547619 | 96 | 0.656683 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
759 | shared.py | ranger_ranger/ranger/core/shared.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""Shared objects contain singletons for shared use."""
from __future__ import (absolute_import, division, print_function)
class FileManagerAware(object): # pylint: disable=too-few-public-methods
"""Subclass this to gain access to the global "FM" object."""
@staticmethod
def fm_set(fm):
FileManagerAware.fm = fm
class SettingsAware(object): # pylint: disable=too-few-public-methods
"""Subclass this to gain access to the global "SettingObject" object."""
@staticmethod
def settings_set(settings):
SettingsAware.settings = settings
| 703 | Python | .py | 14 | 45.928571 | 76 | 0.733529 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
760 | main.py | ranger_ranger/ranger/core/main.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
"""The main function responsible to initialize the FM object and stuff."""
from __future__ import (absolute_import, division, print_function)
import atexit
import locale
import os.path
import shutil
import sys
import tempfile
import urllib
from io import open
from logging import getLogger
from ranger import VERSION
LOG = getLogger(__name__)
VERSION_MSG = [
'ranger version: {0}'.format(VERSION),
'Python version: {0}'.format(' '.join(line.strip() for line in sys.version.splitlines())),
'Locale: {0}'.format('.'.join(str(s) for s in locale.getlocale())),
]
def main(
# pylint: disable=too-many-locals,too-many-return-statements
# pylint: disable=too-many-branches,too-many-statements
):
"""initialize objects and run the filemanager"""
import ranger.api
from ranger.container.settings import Settings
from ranger.core.shared import FileManagerAware, SettingsAware
from ranger.core.fm import FM
from ranger.ext.logutils import setup_logging
from ranger.ext.openstruct import OpenStruct
ranger.args = args = parse_arguments()
ranger.arg = OpenStruct(args.__dict__) # COMPAT
setup_logging(debug=args.debug, logfile=args.logfile)
for line in VERSION_MSG:
LOG.info(line)
LOG.info('Process ID: %s', os.getpid())
try:
locale.setlocale(locale.LC_ALL, '')
except locale.Error:
print("Warning: Unable to set locale. Expect encoding problems.")
# so that programs can know that ranger spawned them:
level = 'RANGER_LEVEL'
if level in os.environ and os.environ[level].isdigit():
os.environ[level] = str(int(os.environ[level]) + 1)
else:
os.environ[level] = '1'
if 'SHELL' not in os.environ:
os.environ['SHELL'] = 'sh'
LOG.debug("cache dir: '%s'", args.cachedir)
LOG.debug("config dir: '%s'", args.confdir)
LOG.debug("data dir: '%s'", args.datadir)
if args.copy_config is not None:
fm = FM()
fm.copy_config_files(args.copy_config)
return 0
if args.list_tagged_files:
if args.clean:
print("Can't access tag data in clean mode", file=sys.stderr)
return 1
fm = FM()
try:
with open(
fm.datapath('tagged'), 'r', encoding="utf-8", errors='replace'
) as fobj:
lines = fobj.readlines()
except OSError as ex:
print('Unable to open `tagged` data file: {0}'.format(ex), file=sys.stderr)
return 1
for line in lines:
if len(line) > 2 and line[1] == ':':
if line[0] in args.list_tagged_files:
sys.stdout.write(line[2:])
elif line and '*' in args.list_tagged_files:
sys.stdout.write(line)
return 0
SettingsAware.settings_set(Settings())
# TODO: deprecate --selectfile
if args.selectfile:
args.selectfile = os.path.abspath(args.selectfile)
args.paths.insert(0, os.path.dirname(args.selectfile))
paths = get_paths(args)
paths_inaccessible = []
for path in paths:
try:
path_abs = os.path.abspath(path)
except OSError:
paths_inaccessible += [path]
continue
if not os.access(path_abs, os.F_OK):
paths_inaccessible += [path]
if paths_inaccessible:
print('Inaccessible paths: {0}'.format(', '.join(paths_inaccessible)),
file=sys.stderr)
return 1
profile = None
exit_msg = ''
exit_code = 0
startup_path_tab_index = 0
try: # pylint: disable=too-many-nested-blocks
# Initialize objects
fm = FM(paths=paths)
FileManagerAware.fm_set(fm)
load_settings(fm, args.clean)
if args.show_only_dirs:
from ranger.container.directory import InodeFilterConstants
fm.settings.global_inode_type_filter = InodeFilterConstants.DIRS
if args.list_unused_keys:
from ranger.ext.keybinding_parser import (special_keys,
reversed_special_keys)
maps = fm.ui.keymaps['browser']
for key in sorted(special_keys.values(), key=str):
if key not in maps:
print("<%s>" % reversed_special_keys[key])
for key in range(33, 127):
if key not in maps:
print(chr(key))
return 0
if not sys.stdin.isatty():
sys.stderr.write("Error: Must run ranger from terminal\n")
raise SystemExit(1)
if fm.username == 'root':
fm.settings.preview_files = False
fm.settings.use_preview_script = False
LOG.info("Running as root, disabling the file previews.")
if not args.debug:
from ranger.ext import curses_interrupt_handler
curses_interrupt_handler.install_interrupt_handler()
if not args.clean:
# Create data directory
if not os.path.exists(args.datadir):
os.makedirs(args.datadir)
# Restore saved tabs
tabs_datapath = fm.datapath('tabs')
if fm.settings.save_tabs_on_exit and os.path.exists(tabs_datapath) and not args.paths:
try:
with open(tabs_datapath, 'r', encoding="utf-8") as fobj:
tabs_saved = fobj.read().partition('\0\0')
startup_path = fm.start_paths.pop(0)
fm.start_paths += tabs_saved[0].split('\0')
# Remove dead entries if this behavior is defined in settings
if fm.settings.filter_dead_tabs_on_startup:
fm.start_paths = list(filter(os.path.isdir, fm.start_paths))
try:
startup_path_tab_index = fm.start_paths.index(startup_path)
except ValueError:
fm.start_paths.insert(0, startup_path)
if tabs_saved[-1]:
with open(tabs_datapath, 'w', encoding="utf-8") as fobj:
fobj.write(tabs_saved[-1])
else:
os.remove(tabs_datapath)
except OSError as ex:
LOG.error('Unable to restore saved tabs')
LOG.exception(ex)
# Run the file manager
fm.initialize()
fm.tab_move(startup_path_tab_index)
ranger.api.hook_init(fm)
fm.ui.initialize()
if args.selectfile:
fm.select_file(args.selectfile)
if args.cmd:
fm.enter_dir(fm.thistab.path)
for command in args.cmd:
fm.execute_console(command)
if int(os.environ[level]) > 1:
warning = 'Warning:'
nested_warning = "You're in a nested ranger instance!"
warn_when_nested = fm.settings.nested_ranger_warning.lower()
if warn_when_nested == 'true':
fm.notify(' '.join((warning, nested_warning)), bad=False)
elif warn_when_nested == 'error':
fm.notify(' '.join((warning.upper(), nested_warning + '!!')),
bad=True)
if ranger.args.profile:
import cProfile
import pstats
ranger.__fm = fm # pylint: disable=protected-access
profile_file = tempfile.gettempdir() + '/ranger_profile'
cProfile.run('ranger.__fm.loop()', profile_file)
profile = pstats.Stats(profile_file, stream=sys.stderr)
else:
fm.loop()
except Exception: # pylint: disable=broad-except
import traceback
ex_traceback = traceback.format_exc()
exit_msg += '\n'.join(VERSION_MSG) + '\n'
try:
exit_msg += "Current file: {0}\n".format(repr(fm.thisfile.path))
except Exception: # pylint: disable=broad-except
pass
exit_msg += '''
{0}
ranger crashed. Please report this traceback at:
https://github.com/ranger/ranger/issues
'''.format(ex_traceback)
exit_code = 1
except SystemExit as ex:
if ex.code is not None:
if not isinstance(ex.code, int):
exit_msg = ex.code
exit_code = 1
else:
exit_code = ex.code
finally:
if exit_msg:
LOG.critical(exit_msg)
try:
fm.ui.destroy()
except (AttributeError, NameError):
pass
# If profiler is enabled print the stats
if ranger.args.profile and profile:
profile.strip_dirs().sort_stats('cumulative').print_callees()
# print the exit message if any
if exit_msg:
sys.stderr.write(exit_msg)
return exit_code # pylint: disable=lost-exception
def get_paths(args):
if args.paths:
prefix = 'file://'
prefix_length = len(prefix)
paths = []
for path in args.paths:
if path.startswith(prefix):
paths.append(urllib.parse.unquote(urllib.parse.urlparse(path).path))
else:
paths.append(path)
else:
start_directory = os.environ.get('PWD')
is_valid_start_directory = start_directory and os.path.exists(start_directory)
if not is_valid_start_directory:
start_directory = __get_home_directory()
paths = [start_directory]
return paths
def __get_home_directory():
return os.path.expanduser('~')
def xdg_path(env_var):
path = os.environ.get(env_var)
if path and os.path.isabs(path):
return os.path.join(path, 'ranger')
return None
def parse_arguments():
"""Parse the program arguments"""
from optparse import OptionParser # pylint: disable=deprecated-module
from ranger import CONFDIR, CACHEDIR, DATADIR, USAGE
parser = OptionParser(usage=USAGE, version=('\n'.join(VERSION_MSG)))
parser.add_option('-d', '--debug', action='store_true',
help="activate debug mode")
parser.add_option('-c', '--clean', action='store_true',
help="don't touch/require any config files. ")
parser.add_option('--logfile', type='string', metavar='file',
help="log file to use, '-' for stderr")
parser.add_option('--cachedir', type='string',
metavar='dir', default=(xdg_path('XDG_CACHE_HOME') or CACHEDIR),
help="change the cache directory. (%default)")
parser.add_option('-r', '--confdir', type='string',
metavar='dir', default=(xdg_path('XDG_CONFIG_HOME') or CONFDIR),
help="change the configuration directory. (%default)")
parser.add_option('--datadir', type='string',
metavar='dir', default=(xdg_path('XDG_DATA_HOME') or DATADIR),
help="change the data directory. (%default)")
parser.add_option('--copy-config', type='string', metavar='which',
help="copy the default configs to the local config directory. "
"Possible values: all, rc, rifle, commands, commands_full, scope")
parser.add_option('--choosefile', type='string', metavar='OUTFILE',
help="Makes ranger act like a file chooser. When opening "
"a file, it will quit and write the name of the selected "
"file to OUTFILE.")
parser.add_option('--choosefiles', type='string', metavar='OUTFILE',
help="Makes ranger act like a file chooser for multiple files "
"at once. When opening a file, it will quit and write the name "
"of all selected files to OUTFILE.")
parser.add_option('--choosedir', type='string', metavar='OUTFILE',
help="Makes ranger act like a directory chooser. When ranger quits"
", it will write the name of the last visited directory to OUTFILE")
parser.add_option('--selectfile', type='string', metavar='filepath',
help="Open ranger with supplied file selected.")
parser.add_option('--show-only-dirs', action='store_true',
help="Show only directories, no files or links")
parser.add_option('--list-unused-keys', action='store_true',
help="List common keys which are not bound to any action.")
parser.add_option('--list-tagged-files', type='string', default=None,
metavar='tag',
help="List all files which are tagged with the given tag, default: *")
parser.add_option('--profile', action='store_true',
help="Print statistics of CPU usage on exit.")
parser.add_option('--cmd', action='append', type='string', metavar='COMMAND',
help="Execute COMMAND after the configuration has been read. "
"Use this option multiple times to run multiple commands.")
args, positional = parser.parse_args()
args.paths = positional
def path_init(option):
argval = args.__dict__[option]
try:
path = os.path.abspath(argval)
except OSError as ex:
sys.stderr.write(
'--{0} is not accessible: {1}\n{2}\n'.format(option, argval, str(ex)))
sys.exit(1)
if os.path.exists(path) and not os.access(path, os.W_OK):
sys.stderr.write('--{0} is not writable: {1}\n'.format(option, path))
sys.exit(1)
return path
if args.clean:
from tempfile import mkdtemp
args.cachedir = mkdtemp(suffix='.ranger-cache')
args.confdir = None
args.datadir = None
@atexit.register
def cleanup_cachedir(): # pylint: disable=unused-variable
try:
shutil.rmtree(args.cachedir)
except Exception as ex: # pylint: disable=broad-except
sys.stderr.write(
"Error during the temporary cache directory cleanup:\n"
"{ex}\n".format(ex=ex)
)
else:
args.cachedir = path_init('cachedir')
args.confdir = path_init('confdir')
args.datadir = path_init('datadir')
if args.choosefile:
args.choosefile = path_init('choosefile')
if args.choosefiles:
args.choosefiles = path_init('choosefiles')
if args.choosedir:
args.choosedir = path_init('choosedir')
return args
COMMANDS_EXCLUDE = ['settings', 'notify']
def load_settings( # pylint: disable=too-many-locals,too-many-branches,too-many-statements
fm, clean):
from ranger.core.actions import Actions
import ranger.core.shared
import ranger.api.commands
from ranger.config import commands as commands_default
# Load default commands
fm.commands = ranger.api.commands.CommandContainer()
include = [name for name in dir(Actions) if name not in COMMANDS_EXCLUDE]
fm.commands.load_commands_from_object(fm, include)
fm.commands.load_commands_from_module(commands_default)
if not clean:
system_confdir = os.path.join(os.sep, 'etc', 'ranger')
if os.path.exists(system_confdir):
sys.path.append(system_confdir)
allow_access_to_confdir(ranger.args.confdir, True)
# Load custom commands
def import_file(name, path): # From https://stackoverflow.com/a/67692
# pragma pylint: disable=no-name-in-module,import-error,no-member, deprecated-method
if sys.version_info >= (3, 5):
from importlib import util
spec = util.spec_from_file_location(name, path)
module = util.module_from_spec(spec)
spec.loader.exec_module(module)
elif (3, 3) <= sys.version_info < (3, 5):
from importlib.machinery import SourceFileLoader
# pylint: disable=no-value-for-parameter
module = SourceFileLoader(name, path).load_module()
else:
import imp # pylint: disable=deprecated-module
module = imp.load_source(name, path)
# pragma pylint: enable=no-name-in-module,import-error,no-member
return module
def load_custom_commands(*paths):
old_bytecode_setting = sys.dont_write_bytecode
sys.dont_write_bytecode = True
for custom_comm_path in paths:
if os.path.exists(custom_comm_path):
try:
commands_custom = import_file('commands',
custom_comm_path)
fm.commands.load_commands_from_module(commands_custom)
except ImportError as ex:
LOG.debug("Failed to import custom commands from '%s'",
custom_comm_path)
LOG.exception(ex)
else:
LOG.debug("Loaded custom commands from '%s'",
custom_comm_path)
sys.dont_write_bytecode = old_bytecode_setting
system_comm_path = os.path.join(system_confdir, 'commands.py')
custom_comm_path = fm.confpath('commands.py')
load_custom_commands(system_comm_path, custom_comm_path)
# XXX Load plugins (experimental)
plugindir = fm.confpath('plugins')
try:
plugin_files = os.listdir(plugindir)
except OSError:
LOG.debug('Unable to access plugin directory: %s', plugindir)
else:
plugins = []
for path in plugin_files:
if not path.startswith('_'):
if path.endswith('.py'):
# remove trailing '.py'
plugins.append(path[:-3])
elif os.path.isdir(os.path.join(plugindir, path)):
plugins.append(path)
if not os.path.exists(fm.confpath('plugins', '__init__.py')):
LOG.debug("Creating missing '__init__.py' file in plugin folder")
with open(
fm.confpath('plugins', '__init__.py'), 'w', encoding="utf-8"
):
# Create the file if it doesn't exist.
pass
ranger.fm = fm
for plugin in sorted(plugins):
try:
try:
# importlib does not exist before python2.7. It's
# required for loading commands from plugins, so you
# can't use that feature in python2.6.
import importlib
except ImportError:
module = __import__('plugins', fromlist=[plugin])
else:
module = importlib.import_module('plugins.' + plugin)
fm.commands.load_commands_from_module(module)
LOG.debug("Loaded plugin '%s'", plugin)
except Exception as ex: # pylint: disable=broad-except
ex_msg = "Error while loading plugin '{0}'".format(plugin)
LOG.error(ex_msg)
LOG.exception(ex)
fm.notify(ex_msg, bad=True)
ranger.fm = None
allow_access_to_confdir(ranger.args.confdir, False)
# Load rc.conf
custom_conf = fm.confpath('rc.conf')
system_conf = os.path.join(system_confdir, 'rc.conf')
default_conf = fm.relpath('config', 'rc.conf')
custom_conf_is_readable = os.access(custom_conf, os.R_OK)
system_conf_is_readable = os.access(system_conf, os.R_OK)
if (os.environ.get('RANGER_LOAD_DEFAULT_RC', 'TRUE').upper() != 'FALSE'
or not (custom_conf_is_readable or system_conf_is_readable)):
fm.source(default_conf)
if system_conf_is_readable:
fm.source(system_conf)
if custom_conf_is_readable:
fm.source(custom_conf)
else:
fm.source(fm.relpath('config', 'rc.conf'))
def allow_access_to_confdir(confdir, allow):
from errno import EEXIST
if allow:
try:
os.makedirs(confdir)
except OSError as err:
if err.errno != EEXIST: # EEXIST means it already exists
print("This configuration directory could not be created:")
print(confdir)
print("To run ranger without the need for configuration")
print("files, use the --clean option.")
raise SystemExit
else:
LOG.debug("Created config directory '%s'", confdir)
if confdir not in sys.path:
sys.path[0:0] = [confdir]
else:
if sys.path[0] == confdir:
del sys.path[0]
| 21,163 | Python | .py | 461 | 33.663774 | 98 | 0.574468 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
761 | filter_stack.py | ranger_ranger/ranger/core/filter_stack.py | # -*- coding: utf-8 -*-
# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# Author: Wojciech Siewierski <[email protected]>, 2018
from __future__ import (absolute_import, division, print_function)
import re
# pylint: disable=invalid-name
try:
from itertools import izip_longest as zip_longest
except ImportError:
from itertools import zip_longest
# pylint: enable=invalid-name
from os.path import abspath
from ranger.core.shared import FileManagerAware
from ranger.ext.hash import hash_chunks
# pylint: disable=too-few-public-methods
class InodeFilterConstants(object):
DIRS = "d"
FILES = "f"
LINKS = "l"
def accept_file(fobj, filters):
"""
Returns True if file shall be shown, otherwise False.
Parameters:
fobj - an instance of FileSystemObject
filters - an array of lambdas, each expects a fobj and
returns True if fobj shall be shown,
otherwise False.
"""
for filt in filters:
if filt and not filt(fobj):
return False
return True
class BaseFilter(object):
def decompose(self):
return [self]
SIMPLE_FILTERS = {}
FILTER_COMBINATORS = {}
def stack_filter(filter_name):
def decorator(cls):
SIMPLE_FILTERS[filter_name] = cls
return cls
return decorator
def filter_combinator(combinator_name):
def decorator(cls):
FILTER_COMBINATORS[combinator_name] = cls
return cls
return decorator
@stack_filter("name")
class NameFilter(BaseFilter):
def __init__(self, pattern):
self.regex = re.compile(pattern)
def __call__(self, fobj):
return self.regex.search(fobj.relative_path)
def __str__(self):
return "<Filter: name =~ /{pat}/>".format(pat=self.regex.pattern)
@stack_filter("mime")
class MimeFilter(BaseFilter, FileManagerAware):
def __init__(self, pattern):
self.regex = re.compile(pattern)
def __call__(self, fobj):
mimetype, _ = self.fm.mimetypes.guess_type(fobj.relative_path)
if mimetype is None:
return False
return self.regex.search(mimetype)
def __str__(self):
return "<Filter: mimetype =~ /{pat}/>".format(pat=self.regex.pattern)
@stack_filter("hash")
class HashFilter(BaseFilter, FileManagerAware):
def __init__(self, filepath=None):
if filepath is None:
self.filepath = self.fm.thisfile.path
else:
self.filepath = filepath
if self.filepath is None:
self.fm.notify("Error: No file selected for hashing!", bad=True)
# TODO: Lazily generated list would be more efficient, a generator
# isn't enough because this object is reused for every fsobject
# in the current directory.
self.filehash = list(hash_chunks(abspath(self.filepath)))
def __call__(self, fobj):
for (chunk1, chunk2) in zip_longest(self.filehash,
hash_chunks(fobj.path),
fillvalue=''):
if chunk1 != chunk2:
return False
return True
def __str__(self):
return "<Filter: hash {fp}>".format(fp=self.filepath)
def group_by_hash(fsobjects):
hashes = {}
for fobj in fsobjects:
chunks = hash_chunks(fobj.path)
chunk = next(chunks)
while chunk in hashes:
for dup in hashes[chunk]:
_, dup_chunks = dup
try:
hashes[next(dup_chunks)] = [dup]
hashes[chunk].remove(dup)
except StopIteration:
pass
try:
chunk = next(chunks)
except StopIteration:
hashes[chunk].append((fobj, chunks))
break
else:
hashes[chunk] = [(fobj, chunks)]
groups = []
for dups in hashes.values():
group = []
for (dup, _) in dups:
group.append(dup)
if group:
groups.append(group)
return groups
@stack_filter("duplicate")
class DuplicateFilter(BaseFilter, FileManagerAware):
def __init__(self, _):
self.duplicates = self.get_duplicates()
def __call__(self, fobj):
return fobj in self.duplicates
def __str__(self):
return "<Filter: duplicate>"
def get_duplicates(self):
duplicates = set()
for dups in group_by_hash(self.fm.thisdir.files_all):
if len(dups) >= 2:
duplicates.update(dups)
return duplicates
@stack_filter("unique")
class UniqueFilter(BaseFilter, FileManagerAware):
def __init__(self, _):
self.unique = self.get_unique()
def __call__(self, fobj):
return fobj in self.unique
def __str__(self):
return "<Filter: unique>"
def get_unique(self):
unique = set()
for dups in group_by_hash(self.fm.thisdir.files_all):
try:
unique.add(min(dups, key=lambda fobj: fobj.stat.st_ctime))
except ValueError:
pass
return unique
@stack_filter("type")
class TypeFilter(BaseFilter):
type_to_function = {
InodeFilterConstants.DIRS:
(lambda fobj: fobj.is_directory),
InodeFilterConstants.FILES:
(lambda fobj: fobj.is_file and not fobj.is_link),
InodeFilterConstants.LINKS:
(lambda fobj: fobj.is_link),
}
def __init__(self, filetype):
if filetype not in self.type_to_function:
raise KeyError(filetype)
self.filetype = filetype
def __call__(self, fobj):
return self.type_to_function[self.filetype](fobj)
def __str__(self):
return "<Filter: type == '{ft}'>".format(ft=self.filetype)
@filter_combinator("or")
class OrFilter(BaseFilter):
def __init__(self, stack):
self.subfilters = [stack[-2], stack[-1]]
stack.pop()
stack.pop()
stack.append(self)
def __call__(self, fobj):
# Turn logical AND (accept_file()) into a logical OR with the
# De Morgan's laws.
return not accept_file(
fobj,
((lambda x, f=filt: not f(x))
for filt
in self.subfilters),
)
def __str__(self):
return "<Filter: {comp}>".format(
comp=" or ".join(map(str, self.subfilters)))
def decompose(self):
return self.subfilters
@filter_combinator("and")
class AndFilter(BaseFilter):
def __init__(self, stack):
self.subfilters = [stack[-2], stack[-1]]
stack.pop()
stack.pop()
stack.append(self)
def __call__(self, fobj):
return accept_file(fobj, self.subfilters)
def __str__(self):
return "<Filter: {comp}>".format(
comp=" and ".join(map(str, self.subfilters)))
def decompose(self):
return self.subfilters
@filter_combinator("not")
class NotFilter(BaseFilter):
def __init__(self, stack):
self.subfilter = stack.pop()
stack.append(self)
def __call__(self, fobj):
return not self.subfilter(fobj)
def __str__(self):
return "<Filter: not {exp}>".format(exp=str(self.subfilter))
def decompose(self):
return [self.subfilter]
| 7,391 | Python | .py | 211 | 26.862559 | 77 | 0.604864 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
762 | tab.py | ranger_ranger/ranger/core/tab.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
from __future__ import (absolute_import, division, print_function)
import os
from os.path import abspath, normpath, join, expanduser, isdir, dirname
from ranger import PY3
from ranger.container import settings
from ranger.container.history import History
from ranger.core.shared import FileManagerAware, SettingsAware
class Tab(FileManagerAware, SettingsAware): # pylint: disable=too-many-instance-attributes
def __init__(self, path):
self.thisdir = None # Current Working Directory
self._thisfile = None # Current File
self.history = History(self.settings.max_history_size, unique=False)
self.last_search = None
self._pointer = 0
self._pointed_obj = None
self.pointed_obj = None
self.path = abspath(expanduser(path))
self.pathway = ()
# NOTE: in the line below, weak=True works only in python3. In python2,
# weak references are not equal to the original object when tested with
# "==", and this breaks _set_thisfile_from_signal and _on_tab_change.
self.fm.signal_bind('move', self._set_thisfile_from_signal,
priority=settings.SIGNAL_PRIORITY_AFTER_SYNC,
weak=(PY3))
self.fm.signal_bind('tab.change', self._on_tab_change,
weak=(PY3))
def _set_thisfile_from_signal(self, signal):
if self == signal.tab:
self._thisfile = signal.new
if self == self.fm.thistab:
self.pointer = self.thisdir.pointer
self.pointed_obj = self.thisdir.pointed_obj
def _on_tab_change(self, signal):
if self == signal.new and self.thisdir:
# restore the pointer whenever this tab is reopened
self.thisdir.pointer = self.pointer
self.thisdir.correct_pointer()
def _set_thisfile(self, value):
if value is not self._thisfile:
previous = self._thisfile
self.fm.signal_emit('move', previous=previous, new=value, tab=self)
def _get_thisfile(self):
return self._thisfile
thisfile = property(_get_thisfile, _set_thisfile)
def _get_pointer(self):
try:
if self.thisdir.files[self._pointer] != self._pointed_obj:
try:
self._pointer = self.thisdir.files.index(self._pointed_obj)
except ValueError:
self._set_pointer(self._pointer)
except (TypeError, IndexError):
pass
return self._pointer
def _set_pointer(self, value):
self._pointer = value
try:
self._pointed_obj = self.thisdir.files[self._pointer]
except (TypeError, IndexError):
pass
pointer = property(_get_pointer, _set_pointer)
def at_level(self, level):
"""Returns the FileSystemObject at the given level.
level >0 => previews
level 0 => current file/directory
level <0 => parent directories
"""
if level <= 0:
try:
return self.pathway[level - 1]
except IndexError:
return None
else:
directory = self.thisdir
for _ in range(level):
if directory is None:
return None
if directory.is_directory:
directory = directory.pointed_obj
else:
return None
return directory
def get_selection(self):
if self.thisdir:
if self.thisdir.marked_items:
return self.thisdir.get_selection()
elif self._thisfile:
return [self._thisfile]
return []
def assign_cursor_positions_for_subdirs(self): # pylint: disable=invalid-name
"""Assign correct cursor positions for subdirectories"""
last_path = None
for path in reversed(self.pathway):
if last_path is None:
last_path = path
continue
path.move_to_obj(last_path)
last_path = path
def ensure_correct_pointer(self):
if self.thisdir:
self.thisdir.correct_pointer()
def history_go(self, relative):
"""Move relative in history"""
if self.history:
self.history.move(relative).go(history=False)
def inherit_history(self, other_history):
self.history.rebase(other_history)
def enter_dir(self, path, history=True):
"""Enter given path"""
# TODO: Ensure that there is always a self.thisdir
if path is None:
return None
path = str(path)
# clear filter in the folder we're leaving
if self.fm.settings.clear_filters_on_dir_change and self.thisdir:
self.thisdir.filter = None
self.thisdir.refilter()
previous = self.thisdir
# get the absolute path
path = normpath(join(self.path, expanduser(path)))
selectfile = None
if not isdir(path):
selectfile = path
path = dirname(path)
new_thisdir = self.fm.get_directory(path)
try:
os.chdir(path)
except OSError:
return True
self.path = path
self.thisdir = new_thisdir
self.thisdir.load_content_if_outdated()
# build the pathway, a tuple of directory objects which lie
# on the path to the current directory.
if path == '/':
self.pathway = (self.fm.get_directory('/'), )
else:
pathway = []
currentpath = '/'
for comp in path.split('/'):
currentpath = join(currentpath, comp)
pathway.append(self.fm.get_directory(currentpath))
self.pathway = tuple(pathway)
self.assign_cursor_positions_for_subdirs()
# set the current file.
self.thisdir.sort_directories_first = self.fm.settings.sort_directories_first
self.thisdir.sort_reverse = self.fm.settings.sort_reverse
self.thisdir.sort_if_outdated()
if selectfile:
self.thisdir.move_to_obj(selectfile)
if previous and previous.path != path:
self.thisfile = self.thisdir.pointed_obj
else:
# This avoids setting self.pointer (through the 'move' signal) and
# is required so that you can use enter_dir when switching tabs
# without messing up the pointer.
self._thisfile = self.thisdir.pointed_obj
if history:
self.history.add(new_thisdir)
self.fm.signal_emit('cd', previous=previous, new=self.thisdir)
return True
def __repr__(self):
return "<Tab '%s'>" % self.thisdir
| 6,924 | Python | .py | 165 | 31.169697 | 91 | 0.599584 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
763 | actions.py | ranger_ranger/ranger/core/actions.py | # This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# pylint: disable=too-many-lines,attribute-defined-outside-init
from __future__ import (absolute_import, division, print_function)
import codecs
import os
import re
import shlex
import shutil
import string
import tempfile
from hashlib import sha512
from inspect import cleandoc
from io import open
from logging import getLogger
from os import link, symlink, listdir, stat
from os.path import join, isdir, realpath, exists
from stat import S_IEXEC
import ranger
from ranger import PY3
from ranger.container.directory import Directory
from ranger.container.file import File
from ranger.container.settings import ALLOWED_SETTINGS, ALLOWED_VALUES
from ranger.core.loader import CommandLoader, CopyLoader
from ranger.core.shared import FileManagerAware, SettingsAware
from ranger.core.tab import Tab
from ranger.ext.direction import Direction
from ranger.ext.get_executables import get_executables
from ranger.ext.keybinding_parser import key_to_string, construct_keybinding
from ranger.ext.macrodict import MacroDict, MACRO_FAIL, macro_val
from ranger.ext.relative_symlink import relative_symlink
from ranger.ext.rifle import squash_flags, ASK_COMMAND
from ranger.ext.safe_path import get_safe_path
from ranger.ext.shell_escape import shell_quote
LOG = getLogger(__name__)
class _MacroTemplate(string.Template):
"""A template for substituting macros in commands"""
delimiter = ranger.MACRO_DELIMITER
idpattern = r"[_a-z0-9]*"
class Actions( # pylint: disable=too-many-instance-attributes,too-many-public-methods
FileManagerAware, SettingsAware):
# --------------------------
# -- Basic Commands
# --------------------------
@staticmethod
def exit():
""":exit
Exit the program.
"""
raise SystemExit
def reset(self):
""":reset
Reset the filemanager, clearing the directory buffer, reload rifle config
"""
old_path = self.thisdir.path
self.previews = {}
self.garbage_collect(-1)
self.enter_dir(old_path)
self.change_mode('normal')
if self.metadata:
self.metadata.reset()
self.rifle.reload_config()
self.fm.tags.sync()
def change_mode(self, mode=None):
""":change_mode <mode>
Change mode to "visual" (selection) or "normal" mode.
"""
if mode is None:
self.fm.notify('Syntax: change_mode <mode>', bad=True)
return
if mode == self.mode: # pylint: disable=access-member-before-definition
return
if mode == 'visual':
self._visual_pos_start = self.thisdir.pointer
self._visual_move_cycles = 0
self._previous_selection = set(self.thisdir.marked_items)
self.mark_files(val=not self._visual_reverse, movedown=False)
elif mode == 'normal':
if self.mode == 'visual': # pylint: disable=access-member-before-definition
self._visual_pos_start = None
self._visual_move_cycles = None
self._previous_selection = None
else:
return
self.mode = mode
self.ui.status.request_redraw()
def set_option_from_string(self, option_name, value, localpath=None, tags=None):
if option_name not in ALLOWED_SETTINGS:
raise ValueError("The option named `%s' does not exist" % option_name)
if not isinstance(value, str):
raise ValueError("The value for an option needs to be a string.")
self.settings.set(option_name, self._parse_option_value(option_name, value),
localpath, tags)
def _parse_option_value( # pylint: disable=too-many-return-statements
self, name, value):
types = self.fm.settings.types_of(name)
if bool in types:
if value.lower() in ('false', 'off', '0'):
return False
elif value.lower() in ('true', 'on', '1'):
return True
if isinstance(None, types) and value.lower() == 'none':
return None
if int in types:
try:
return int(value)
except ValueError:
pass
if float in types:
try:
return float(value)
except ValueError:
pass
if str in types:
return value
if list in types:
return value.split(',')
raise ValueError("Invalid value `%s' for option `%s'!" % (name, value))
def toggle_visual_mode(self, reverse=False, narg=None):
""":toggle_visual_mode
Toggle the visual mode (see :change_mode).
"""
if self.mode == 'normal':
self._visual_reverse = reverse
if narg is not None:
self.mark_files(val=not reverse, narg=narg)
self.change_mode('visual')
else:
self.change_mode('normal')
def reload_cwd(self):
""":reload_cwd
Reload the current working directory.
"""
try:
cwd = self.thisdir
except AttributeError:
pass
else:
cwd.unload()
cwd.load_content()
def notify(self, obj, duration=4, bad=False, exception=None):
""":notify <text>
Display the text in the statusbar.
"""
if isinstance(obj, Exception):
if ranger.args.debug:
raise obj
exception = obj
bad = True
elif bad and ranger.args.debug:
class BadNotification(Exception):
pass
raise BadNotification(str(obj))
text = str(obj)
text_log = 'Notification: {0}'.format(text)
if bad:
LOG.error(text_log)
else:
LOG.info(text_log)
if exception:
LOG.exception(exception)
if self.ui and self.ui.is_on:
self.ui.status.notify(" ".join(text.split("\n")),
duration=duration, bad=bad)
else:
print(text)
def abort(self):
""":abort
Empty the first queued action.
"""
try:
item = self.loader.queue[0]
except IndexError:
self.notify("Type Q or :quit<Enter> to exit ranger")
else:
self.notify("Aborting: " + item.get_description())
self.loader.remove(index=0)
def get_cumulative_size(self):
for fobj in self.thistab.get_selection() or ():
fobj.look_up_cumulative_size()
self.ui.status.request_redraw()
self.ui.redraw_main_column()
def redraw_window(self):
""":redraw_window
Redraw the window.
"""
self.ui.redraw_window()
def open_console(self, string='', # pylint: disable=redefined-outer-name
prompt=None, position=None):
""":open_console [string]
Open the console.
"""
self.change_mode('normal')
self.ui.open_console(string, prompt=prompt, position=position)
def execute_console(self, string='', # pylint: disable=redefined-outer-name
wildcards=None, quantifier=None):
""":execute_console [string]
Execute a command for the console
"""
command_name = string.lstrip().split()[0]
cmd_class = self.commands.get_command(command_name)
if cmd_class is None:
self.notify("Command not found: `%s'" % command_name, bad=True)
return None
cmd = cmd_class(string, quantifier=quantifier)
if cmd.resolve_macros and _MacroTemplate.delimiter in cmd.line:
def any_macro(i, char):
return ('any{0:d}'.format(i), key_to_string(char))
def anypath_macro(i, char):
try:
val = self.fm.bookmarks[key_to_string(char)]
except KeyError:
val = MACRO_FAIL
return ('any_path{0:d}'.format(i), val)
macros = dict(f(i, char) for f in (any_macro, anypath_macro)
for i, char in enumerate(wildcards if wildcards
is not None else []))
if 'any0' in macros:
macros['any'] = macros['any0']
if 'any_path0' in macros:
macros['any_path'] = macros['any_path0']
try:
line = self.substitute_macros(cmd.line, additional=macros,
escape=cmd.escape_macros_for_shell)
except ValueError as ex:
if ranger.args.debug:
raise
return self.notify(ex)
cmd.init_line(line)
try:
cmd.execute()
except Exception as ex: # pylint: disable=broad-except
if ranger.args.debug:
raise
self.notify(ex)
return None
def substitute_macros(self, string, # pylint: disable=redefined-outer-name
additional=None, escape=False):
macros = self.get_macros()
if additional:
macros.update(additional)
if escape:
for key, value in macros.items():
if isinstance(value, list):
macros[key] = " ".join(shell_quote(s) for s in value)
elif value != MACRO_FAIL:
macros[key] = shell_quote(value)
else:
for key, value in macros.items():
if isinstance(value, list):
macros[key] = " ".join(value)
result = _MacroTemplate(string).safe_substitute(macros)
if MACRO_FAIL in result:
raise ValueError("Could not apply macros to `%s'" % string)
return result
def get_macros(self):
macros = MacroDict()
macros['rangerdir'] = ranger.RANGERDIR
if not ranger.args.clean:
macros['confdir'] = self.fm.confpath()
macros['datadir'] = self.fm.datapath()
macros['space'] = ' '
macros['f'] = lambda: self.fm.thisfile.relative_path
macros['p'] = lambda: [os.path.join(self.fm.thisdir.path,
fl.relative_path) for fl in
self.fm.thistab.get_selection()]
macros['s'] = lambda: [fl.relative_path for fl in
self.fm.thistab.get_selection()]
macros['c'] = lambda: [fl.path for fl in self.fm.copy_buffer]
macros['t'] = lambda: [fl.relative_path for fl in
self.fm.thisdir.files if fl.realpath in
self.fm.tags]
macros['d'] = macro_val(lambda: self.fm.thisdir.path, fallback='.')
# define d/f/p/s macros for each tab
for i in range(1, 10):
# pylint: disable=cell-var-from-loop
try:
tab = self.fm.tabs[i]
tabdir = tab.thisdir
except (KeyError, AttributeError):
continue
if not tabdir:
continue
i = str(i)
macros[i + 'd'] = lambda: tabdir.path
macros[i + 'p'] = lambda: [os.path.join(tabdir.path,
fl.relative_path) for fl in
tabdir.get_selection()]
macros[i + 's'] = lambda: [fl.path for fl in tabdir.get_selection()]
macros[i + 'f'] = lambda: tabdir.pointed_obj.path
# define D/F/P/S for the next tab
found_current_tab = False
next_tab = None
first_tab = None
for tabname in self.fm.tabs:
if not first_tab:
first_tab = tabname
if found_current_tab:
next_tab = self.fm.tabs[tabname]
break
if self.fm.current_tab == tabname:
found_current_tab = True
if found_current_tab and next_tab is None:
next_tab = self.fm.tabs[first_tab]
try:
next_tab_dir = next_tab.thisdir
except AttributeError:
return macros
macros['D'] = lambda: str(next_tab_dir.path)
macros['F'] = lambda: next_tab.thisfile.path
macros['P'] = lambda: [os.path.join(next_tab.path, fl.path)
for fl in next_tab.get_selection()]
macros['S'] = lambda: [fl.path for fl in next_tab.get_selection()]
return macros
def source(self, filename):
""":source <filename>
Load a config file.
"""
filename = os.path.expanduser(filename)
LOG.debug("Sourcing config file '%s'", filename)
# pylint: disable=unspecified-encoding
with open(filename, 'r', encoding="utf-8") as fobj:
for line in fobj:
line = line.strip(" \r\n")
if line.startswith("#") or not line.strip():
continue
try:
if not isinstance(line, str):
line = line.encode("ascii")
self.execute_console(line)
except Exception as ex: # pylint: disable=broad-except
if ranger.args.debug:
raise
self.notify('Error in line `%s\':\n %s' % (line, str(ex)), bad=True)
def execute_file(self, files, **kw): # pylint: disable=too-many-branches
"""Uses the "rifle" module to open/execute a file
Arguments are the same as for ranger.ext.rifle.Rifle.execute:
files: a list of file objects (not strings!)
number: a number to select which way to open the file, in case there
are multiple choices
label: a string to select an opening method by its label
flags: a string specifying additional options, see `man rifle`
mimetype: pass the mimetype to rifle, overriding its own guess
"""
mode = kw['mode'] if 'mode' in kw else 0
# ranger can act as a file chooser when running with --choosefile=...
if mode == 0 and 'label' not in kw:
if ranger.args.choosefile:
with open(
ranger.args.choosefile, 'w', encoding="utf-8"
) as fobj:
fobj.write(self.fm.thisfile.path)
if ranger.args.choosefiles:
paths = []
for hist in self.fm.thistab.history:
for fobj in hist.files:
if fobj.marked and fobj.path not in paths:
paths += [fobj.path]
paths += [f.path for f in self.fm.thistab.get_selection() if f.path not in paths]
with open(
ranger.args.choosefiles, 'w', encoding="utf-8"
) as fobj:
fobj.write('\n'.join(paths) + '\n')
if ranger.args.choosefile or ranger.args.choosefiles:
raise SystemExit
if isinstance(files, set):
files = list(files)
elif not isinstance(files, (list, tuple)):
files = [files]
flags = kw.get('flags', '')
if 'c' in squash_flags(flags):
files = [self.fm.thisfile]
self.signal_emit('execute.before', keywords=kw)
filenames = [f.path for f in files]
label = kw.get('label', kw.get('app', None))
def execute():
return self.rifle.execute(filenames, mode, label, flags, None)
try:
return execute()
except OSError as err:
# Argument list too long.
if err.errno == 7 and self.settings.open_all_images:
old_value = self.settings.open_all_images
try:
self.notify("Too many files: Disabling open_all_images temporarily.")
self.settings.open_all_images = False
return execute()
finally:
self.settings.open_all_images = old_value
else:
raise
finally:
self.signal_emit('execute.after')
# --------------------------
# -- Moving Around
# --------------------------
def move(self, # pylint: disable=too-many-locals,too-many-branches,too-many-statements
narg=None, **kw):
"""A universal movement method.
Accepts these parameters:
(int) down, (int) up, (int) left, (int) right, (int) to,
(bool) absolute, (bool) relative, (bool) pages,
(bool) percentage
to=X is translated to down=X, absolute=True
Example:
self.move(down=4, pages=True) # moves down by 4 pages.
self.move(to=2, pages=True) # moves to page 2.
self.move(to=80, percentage=True) # moves to 80%
"""
cwd = self.thisdir
kw.setdefault('cycle', self.fm.settings['wrap_scroll'])
kw.setdefault('one_indexed', self.fm.settings['one_indexed'])
direction = Direction(kw)
if 'left' in direction or direction.left() > 0:
steps = direction.left()
if narg is not None:
steps *= narg
directory = os.path.join(*(['..'] * steps))
self.thistab.enter_dir(directory)
self.change_mode('normal')
if not cwd or not cwd.accessible or not cwd.content_loaded:
return
if 'right' in direction:
mode = 0
if narg is not None:
mode = narg
tfile = self.thisfile
if kw.get('selection', True):
selection = self.thistab.get_selection()
else:
selection = [tfile]
if tfile is None:
return
if tfile.is_directory:
self.thistab.enter_dir(tfile)
elif selection:
result = self.execute_file(selection, mode=mode)
if result in (False, ASK_COMMAND):
self.open_console('open_with ')
elif direction.vertical() and cwd.files:
pos_new = direction.move(
direction=direction.down(),
override=narg,
maximum=len(cwd),
current=cwd.pointer,
pagesize=self.ui.browser.hei)
cwd.move(to=pos_new)
if self.mode == 'visual':
pos_start = min(self._visual_pos_start, (len(cwd.files) - 1))
self._visual_move_cycles += direction.move_cycles()
# Haven't cycled
if self._visual_move_cycles == 0:
targets = set(cwd.files[min(pos_start, pos_new):(max(pos_start, pos_new) + 1)])
# Cycled down once
elif self._visual_move_cycles == 1:
if pos_new < pos_start:
targets = set(cwd.files[:(pos_new + 1)] + cwd.files[pos_start:])
else:
targets = set(cwd.files)
# Cycled up once
elif self._visual_move_cycles == -1:
if pos_new > pos_start:
targets = set(cwd.files[:(pos_start + 1)] + cwd.files[pos_new:])
else:
targets = set(cwd.files)
# Cycled more than once
else:
targets = set(cwd.files)
# The current selection
current = set(cwd.marked_items)
# Set theory anyone?
if self._visual_reverse:
for fobj in targets & current:
cwd.mark_item(fobj, False)
for fobj in self._previous_selection - current - targets:
cwd.mark_item(fobj, True)
else:
for fobj in targets - current:
cwd.mark_item(fobj, True)
for fobj in current - self._previous_selection - targets:
cwd.mark_item(fobj, False)
if self.ui.pager.visible:
self.display_file()
def move_parent(self, n, narg=None):
self.change_mode('normal')
if narg is not None:
n *= narg
parent = self.thistab.at_level(-1)
if parent is not None:
if parent.pointer + n < 0:
n = 0 - parent.pointer
try:
self.thistab.enter_dir(parent.files[parent.pointer + n])
except IndexError:
pass
def select_file(self, path):
path = path.strip()
if self.enter_dir(os.path.dirname(path)):
self.thisdir.move_to_obj(path)
def history_go(self, relative):
"""Move back and forth in the history"""
self.thistab.history_go(int(relative))
# TODO: remove this method since it is not used?
def scroll(self, relative):
"""Scroll down by <relative> lines"""
if self.ui.browser and self.ui.browser.main_column:
self.ui.browser.main_column.scroll(relative)
self.thisfile = self.thisdir.pointed_obj
def enter_dir(self, path, remember=False, history=True):
"""Enter the directory at the given path"""
cwd = self.thisdir
# csh variable is lowercase
cdpath = os.environ.get('CDPATH', None) or os.environ.get('cdpath', None)
result = self.thistab.enter_dir(path, history=history)
if result is False and cdpath:
for comp in cdpath.split(':'):
curpath = os.path.join(comp, path)
if os.path.isdir(curpath):
result = self.thistab.enter_dir(curpath, history=history)
break
if cwd != self.thisdir:
if remember:
self.bookmarks.remember(cwd)
self.change_mode('normal')
return result
def cd(self, path, remember=True): # pylint: disable=invalid-name
"""enter the directory at the given path, remember=True"""
self.enter_dir(path, remember=remember)
def traverse(self):
self.change_mode('normal')
tfile = self.thisfile
cwd = self.thisdir
if tfile is not None and tfile.is_directory:
self.enter_dir(tfile.path)
elif cwd.pointer >= len(cwd) - 1:
while True:
self.move(left=1)
cwd = self.thisdir
if cwd.pointer < len(cwd) - 1:
break
if cwd.path == '/':
break
self.move(down=1)
self.traverse()
else:
self.move(down=1)
self.traverse()
def traverse_backwards(self):
self.change_mode('normal')
if self.thisdir.pointer == 0:
self.move(left=1)
if self.thisdir.pointer != 0:
self.traverse_backwards()
else:
self.move(up=1)
while True:
if self.thisfile is not None and self.thisfile.is_directory:
self.enter_dir(self.thisfile.path)
self.move(to=100, percentage=True)
elif self.thisdir.pointer == 0:
break
else:
self.move(up=1)
# --------------------------
# -- Shortcuts / Wrappers
# --------------------------
def pager_move(self, narg=None, **kw):
self.ui.get_pager().move(narg=narg, **kw)
def taskview_move(self, narg=None, **kw):
self.ui.taskview.move(narg=narg, **kw)
def pause_tasks(self):
self.loader.pause(-1)
def pager_close(self):
if self.ui.pager.visible:
self.ui.close_pager()
if self.ui.browser.pager and self.ui.browser.pager.visible:
self.ui.close_embedded_pager()
def taskview_open(self):
self.ui.open_taskview()
def taskview_close(self):
self.ui.close_taskview()
def execute_command(self, cmd, **kw):
return self.run(cmd, **kw)
def edit_file(self, file=None): # pylint: disable=redefined-builtin
"""Calls execute_file with the current file and label='editor'"""
if file is None:
file = self.thisfile
elif isinstance(file, str):
file = File(os.path.expanduser(file))
if file is None:
return
self.execute_file(file, label='editor')
def toggle_option(self, string): # pylint: disable=redefined-outer-name
""":toggle_option <string>
Toggle a boolean option named <string>.
"""
if isinstance(self.settings[string], bool):
self.settings[string] ^= True
elif string in ALLOWED_VALUES:
current = self.settings[string]
allowed = ALLOWED_VALUES[string]
if allowed:
if current not in allowed and current == "":
current = allowed[0]
if current in allowed:
self.settings[string] = \
allowed[(allowed.index(current) + 1) % len(allowed)]
else:
self.settings[string] = allowed[0]
def set_option(self, optname, value):
""":set_option <optname>
Set the value of an option named <optname>.
"""
self.settings[optname] = value
def sort(self, func=None, reverse=None):
if reverse is not None:
self.settings['sort_reverse'] = bool(reverse)
if func is not None:
self.settings['sort'] = str(func)
def mark_files(self, all=False, # pylint: disable=redefined-builtin,too-many-arguments
toggle=False, val=None, movedown=None, narg=None):
"""A wrapper for the directory.mark_xyz functions.
Arguments:
all - change all files of the current directory at once?
toggle - toggle the marked-status?
val - mark or unmark?
"""
if self.thisdir is None:
return
cwd = self.thisdir
if not cwd.accessible:
return
if movedown is None:
movedown = not all
if val is None and toggle is False:
return
if narg is None:
narg = 1
else:
all = False
if all:
if toggle:
cwd.toggle_all_marks()
else:
cwd.mark_all(val)
if self.mode == 'visual':
self.change_mode('normal')
else:
for i in range(cwd.pointer, min(cwd.pointer + narg, len(cwd))):
item = cwd.files[i]
if item is not None:
if toggle:
cwd.toggle_mark(item)
else:
cwd.mark_item(item, val)
if movedown:
self.move(down=narg)
self.ui.redraw_main_column()
self.ui.status.need_redraw = True
def mark_in_direction(self, val=True, dirarg=None):
cwd = self.thisdir
direction = Direction(dirarg)
pos, selected = direction.select(lst=cwd.files, current=cwd.pointer,
pagesize=self.ui.termsize[0])
cwd.pointer = pos
cwd.correct_pointer()
for item in selected:
cwd.mark_item(item, val)
# --------------------------
# -- Searching
# --------------------------
# TODO: Do we still use this method? Should we remove it?
def search_file(self, text, offset=1, regexp=True):
if isinstance(text, str) and regexp:
try:
text = re.compile(text, re.UNICODE | re.IGNORECASE) # pylint: disable=no-member
except re.error:
return False
self.thistab.last_search = text
self.search_next(order='search', offset=offset)
return None
def search_next(self, order=None, offset=1, forward=True):
original_order = order
if order is None:
order = self.search_method
else:
self.set_search_method(order=order)
if order in ('search', 'tag'):
if order == 'search':
arg = self.thistab.last_search
if arg is None:
return False
if hasattr(arg, 'search'):
def fnc(obj):
return arg.search(obj.basename)
else:
def fnc(obj):
return arg in obj.basename
elif order == 'tag':
def fnc(obj):
return obj.realpath in self.tags
return self.thisdir.search_fnc(fnc=fnc, offset=offset, forward=forward)
elif order in ('size', 'mimetype', 'ctime', 'mtime', 'atime'):
cwd = self.thisdir
if original_order is not None or not cwd.cycle_list:
lst = list(cwd.files)
if order == 'size':
def fnc(item):
return -item.size
elif order == 'mimetype':
def fnc(item):
return item.mimetype or ''
elif order == 'ctime':
def fnc(item):
return -int(item.stat and item.stat.st_ctime)
elif order == 'atime':
def fnc(item):
return -int(item.stat and item.stat.st_atime)
elif order == 'mtime':
def fnc(item):
return -int(item.stat and item.stat.st_mtime)
lst.sort(key=fnc)
cwd.set_cycle_list(lst)
return cwd.cycle(forward=None)
return cwd.cycle(forward=forward)
return None
def set_search_method(self, order, forward=True): # pylint: disable=unused-argument
if order in ('search', 'tag', 'size', 'mimetype', 'ctime', 'mtime', 'atime'):
self.search_method = order
# --------------------------
# -- Tags
# --------------------------
# Tags are saved in ~/.config/ranger/tagged and simply mark if a
# file is important to you in any context.
def tag_toggle(self, tag=None, paths=None, value=None, movedown=None):
""":tag_toggle <character>
Toggle a tag <character>.
Keyword arguments:
tag=<character>
paths=<paths to tag>
value=<True: add/False: remove/anything else: toggle>
movedown=<boolean>
"""
if not self.tags:
return
if paths is None:
tags = tuple(x.realpath for x in self.thistab.get_selection())
else:
tags = [realpath(path) for path in paths]
if value is True:
self.tags.add(*tags, tag=tag or self.tags.default_tag)
elif value is False:
self.tags.remove(*tags)
else:
self.tags.toggle(*tags, tag=tag or self.tags.default_tag)
if movedown is None:
movedown = len(tags) == 1 and paths is None
if movedown:
self.move(down=1)
self.ui.redraw_main_column()
def tag_remove(self, tag=None, paths=None, movedown=None):
""":tag_remove <character>
Remove a tag <character>. See :tag_toggle for keyword arguments.
"""
self.tag_toggle(tag=tag, paths=paths, value=False, movedown=movedown)
def tag_add(self, tag=None, paths=None, movedown=None):
""":tag_add <character>
Add a tag <character>. See :tag_toggle for keyword arguments.
"""
self.tag_toggle(tag=tag, paths=paths, value=True, movedown=movedown)
# --------------------------
# -- Bookmarks
# --------------------------
# Using ranger.container.bookmarks.
def enter_bookmark(self, key):
"""Enter the bookmark with the name <key>"""
try:
self.bookmarks.update_if_outdated()
destination = self.bookmarks[str(key)]
cwd = self.thisdir
if destination.path != cwd.path:
self.bookmarks.enter(str(key))
self.bookmarks.remember(cwd)
except KeyError:
pass
def set_bookmark(self, key, val=None):
"""Set the bookmark with the name <key> to the current directory"""
if val is None:
val = self.thisdir
else:
val = Directory(val)
self.bookmarks.update_if_outdated()
self.bookmarks[str(key)] = val
def unset_bookmark(self, key):
"""Delete the bookmark with the name <key>"""
self.bookmarks.update_if_outdated()
del self.bookmarks[str(key)]
def draw_bookmarks(self):
self.ui.browser.draw_bookmarks = True
def hide_bookmarks(self):
self.ui.browser.draw_bookmarks = False
def draw_possible_programs(self):
try:
target = self.thistab.get_selection()[0]
except IndexError:
self.ui.browser.draw_info = []
return
programs = list(self.rifle.list_commands(
[target.path], None, skip_ask=True))
if programs:
num_digits = max((len(str(program[0])) for program in programs))
program_info = ['%s | %s' % (str(program[0]).rjust(num_digits), program[1])
for program in programs]
self.ui.browser.draw_info = program_info
def hide_console_info(self):
self.ui.browser.draw_info = False
# --------------------------
# -- Pager
# --------------------------
# These commands open the built-in pager and set specific sources.
def display_command_help(self, console_widget):
try:
command = console_widget.get_cmd_class()
except KeyError:
self.notify("Feature not available!", bad=True)
return
if not command:
self.notify("Command not found!", bad=True)
return
if not command.__doc__:
self.notify("Command has no docstring. Try using python without -OO", bad=True)
return
pager = self.ui.open_pager()
lines = cleandoc(command.__doc__).split('\n')
pager.set_source(lines)
def display_help(self):
if 'man' in get_executables():
manualpath = self.relpath('../doc/ranger.1')
if os.path.exists(manualpath):
process = self.run(['man', manualpath])
if process.poll() != 16:
return
process = self.run(['man', 'ranger'])
if process.poll() == 16:
self.notify("Could not find manpage.", bad=True)
else:
self.notify("Failed to show man page, check if man is installed",
bad=True)
def display_log(self):
logs = list(self.get_log())
pager = self.ui.open_pager()
if logs:
pager.set_source(["Message Log:"] + logs)
else:
pager.set_source(["Message Log:", "No messages!"])
pager.move(to=100, percentage=True)
def display_file(self):
if not self.thisfile or not self.thisfile.is_file:
return
pager = self.ui.open_pager()
fobj = self.thisfile.get_preview_source(pager.wid, pager.hei)
if self.thisfile.is_image_preview():
pager.set_image(fobj)
else:
pager.set_source(fobj)
def scroll_preview(self, lines, narg=None):
""":scroll_preview <lines>
Scroll the file preview by <lines> lines.
"""
preview_column = self.ui.browser.columns[-1]
if preview_column.target and preview_column.target.is_file:
if narg is not None:
lines = narg
preview_column.scrollbit(lines)
# --------------------------
# -- Previews
# --------------------------
def update_preview(self, path):
try:
del self.previews[path]
self.signal_emit('preview.cleared', path=path)
except KeyError:
return False
self.ui.need_redraw = True
return True
@staticmethod
def sha512_encode(path, inode=None):
if inode is None:
inode = stat(path).st_ino
inode_path = "{0}{1}".format(str(inode), path)
if PY3:
inode_path = inode_path.encode('utf-8', 'backslashreplace')
return '{0}.jpg'.format(sha512(inode_path).hexdigest())
def get_preview(self, fobj, width, height):
# pylint: disable=too-many-return-statements,too-many-statements
pager = self.ui.get_pager()
path = fobj.realpath
if not path or not os.path.exists(path):
return None
if not self.settings.preview_script or not self.settings.use_preview_script:
try:
# XXX: properly determine file's encoding
# Disable the lint because the preview is read outside the
# local scope.
# pylint: disable=consider-using-with
return codecs.open(path, 'r', errors='ignore')
# IOError for Python2, OSError for Python3
except (IOError, OSError):
return None
# self.previews is a 2 dimensional dict:
# self.previews['/tmp/foo.jpg'][(80, 24)] = "the content..."
# self.previews['/tmp/foo.jpg']['loading'] = False
# A -1 in tuples means "any"; (80, -1) = wid. of 80 and any hei.
# The key 'foundpreview' is added later. Values in (True, False)
# XXX: Previews can break when collapse_preview is on and the
# preview column is popping out as you move the cursor on e.g. a
# PDF file.
try:
data = self.previews[path]
except KeyError:
data = self.previews[path] = {'loading': False}
else:
if data['loading']:
return None
found = data.get(
(-1, -1), data.get(
(width, -1), data.get(
(-1, height), data.get(
(width, height), False
)
)
)
)
if found is not False:
return found
try:
stat_ = os.stat(self.settings.preview_script)
except OSError:
self.fm.notify("Preview script `{0}` doesn't exist!".format(
self.settings.preview_script), bad=True)
return None
if not stat_.st_mode & S_IEXEC:
self.fm.notify("Preview script `{0}` is not executable!".format(
self.settings.preview_script), bad=True)
return None
data['loading'] = True
if 'directimagepreview' in data:
data['foundpreview'] = True
data['imagepreview'] = True
pager.set_image(path)
data['loading'] = False
return path
if not os.path.exists(ranger.args.cachedir):
os.makedirs(ranger.args.cachedir)
fobj.load_if_outdated()
cacheimg = os.path.join(
ranger.args.cachedir,
self.sha512_encode(path, inode=fobj.stat.st_ino)
)
if (self.settings.preview_images and os.path.isfile(cacheimg)
and fobj.stat.st_mtime <= os.path.getmtime(cacheimg)):
data['foundpreview'] = True
data['imagepreview'] = True
pager.set_image(cacheimg)
data['loading'] = False
return cacheimg
def on_after(signal):
rcode = signal.process.poll()
content = signal.loader.stdout_buffer
data['foundpreview'] = True
if rcode == 0:
data[(width, height)] = content
elif rcode == 3:
data[(-1, height)] = content
elif rcode == 4:
data[(width, -1)] = content
elif rcode == 5:
data[(-1, -1)] = content
elif rcode == 6:
data['imagepreview'] = True
elif rcode == 7:
data['directimagepreview'] = True
elif rcode == 1:
data[(-1, -1)] = None
data['foundpreview'] = False
elif rcode == 2:
text = self.read_text_file(path, 1024 * 32)
if text is not None and not isinstance(text, str):
# Convert 'unicode' to 'str' in Python 2
text = text.encode('utf-8')
data[(-1, -1)] = text
else:
data[(-1, -1)] = None
if self.thisfile and self.thisfile.realpath == path:
self.ui.browser.need_redraw = True
data['loading'] = False
pager = self.ui.get_pager()
if self.thisfile and self.thisfile.is_file:
if 'imagepreview' in data:
pager.set_image(cacheimg)
return cacheimg
elif 'directimagepreview' in data:
pager.set_image(path)
return path
else:
pager.set_source(self.thisfile.get_preview_source(
pager.wid, pager.hei))
return None
def on_destroy(signal): # pylint: disable=unused-argument
try:
del self.previews[path]
except KeyError:
pass
loadable = CommandLoader(
args=[self.settings.preview_script, path, str(width), str(height),
cacheimg, str(self.settings.preview_images)],
read=True,
silent=True,
descr="Getting preview of %s" % path,
)
loadable.signal_bind('after', on_after)
loadable.signal_bind('destroy', on_destroy)
self.loader.add(loadable)
return None
@staticmethod
def read_text_file(path, count=None):
"""Encoding-aware reading of a text file."""
# Guess encoding ourselves.
# These should be the most frequently used ones.
# latin-1 as the last resort
encodings = [('utf-8', 'strict'), ('utf-16', 'strict'),
('latin-1', 'replace')]
with open(path, 'rb') as fobj:
data = fobj.read(count)
try:
import chardet
except ImportError:
pass
else:
result = chardet.detect(data)
guessed_encoding = result['encoding']
if guessed_encoding is not None:
# Add chardet's guess before our own.
encodings.insert(0, (guessed_encoding, 'replace'))
for (encoding, error_scheme) in encodings:
try:
text = codecs.decode(data, encoding, error_scheme)
except UnicodeDecodeError:
return None
else:
LOG.debug("Guessed encoding of '%s' as %s", path, encoding)
return text
# --------------------------
# -- Tabs
# --------------------------
def tab_open(self, name, path=None):
tab_has_changed = (name != self.current_tab)
self.current_tab = name
previous_tab = self.thistab
try:
tab = self.tabs[name]
except KeyError:
# create a new tab
tab = Tab(self.thistab.path)
self.tabs[name] = tab
self.thistab = tab
tab.enter_dir(tab.path, history=False)
if path:
tab.enter_dir(path, history=True)
if previous_tab:
tab.inherit_history(previous_tab.history)
else:
self.thistab = tab
if path:
tab.enter_dir(path, history=True)
else:
if os.path.isdir(tab.path):
tab.enter_dir(tab.path, history=False)
else:
tab.thisdir = None
if tab_has_changed:
self.change_mode('normal')
self.signal_emit('tab.change', old=previous_tab, new=self.thistab)
self.signal_emit('tab.layoutchange')
def tabopen(self, *args, **kwargs):
return self.tab_open(*args, **kwargs)
def tab_close(self, name=None):
if name is None:
name = self.current_tab
tab = self.tabs[name]
if name == self.current_tab:
direction = -1 if name == self.get_tab_list()[-1] else 1
previous = self.current_tab
self.tab_move(direction)
if previous == self.current_tab:
return # can't close last tab
if name in self.tabs:
del self.tabs[name]
self.restorable_tabs.append(tab)
self.signal_emit('tab.layoutchange')
def tabclose(self, *args, **kwargs):
return self.tab_close(*args, **kwargs)
def tab_restore(self):
# NOTE: The name of the tab is not restored.
previous_tab = self.thistab
if self.restorable_tabs:
tab = self.restorable_tabs.pop()
for name in range(1, len(self.tabs) + 2):
if name not in self.tabs:
self.current_tab = name
self.tabs[name] = tab
tab.enter_dir(tab.path, history=False)
self.thistab = tab
self.change_mode('normal')
self.signal_emit('tab.change', old=previous_tab, new=self.thistab)
break
def tabrestore(self, *args, **kwargs):
return self.tab_restore(*args, **kwargs)
def tab_move(self, offset, narg=None):
if narg:
return self.tab_open(narg)
assert isinstance(offset, int)
tablist = self.get_tab_list()
current_index = tablist.index(self.current_tab)
newtab = tablist[(current_index + offset) % len(tablist)]
if newtab != self.current_tab:
self.tab_open(newtab)
return None
def tabmove(self, *args, **kwargs):
return self.tab_move(*args, **kwargs)
def tab_new(self, path=None, narg=None):
if narg:
return self.tab_open(narg, path)
i = 1
while i in self.tabs:
i += 1
return self.tab_open(i, path)
def tabnew(self, *args, **kwargs):
return self.tab_new(*args, **kwargs)
def tab_shift(self, offset=0, to=None): # pylint: disable=invalid-name
"""Shift the tab left/right
Shift the current tab to the left or right by either:
offset - changes the tab number by offset
to - shifts the tab to the specified tab number
"""
oldtab_index = self.current_tab
if to is None:
assert isinstance(offset, int)
# enumerated index (1 to 9)
newtab_index = oldtab_index + offset
else:
assert isinstance(to, int)
newtab_index = to
# shift tabs without enumerating, preserve tab numbers when can
if newtab_index != oldtab_index:
# the other tabs shift in the opposite direction
if (newtab_index - oldtab_index) > 0:
direction = -1
else:
direction = 1
def tabshiftreorder(source_index):
# shift the tabs to make source_index empty
if source_index in self.tabs:
target_index = source_index + direction
# make the target_index empty recursively
tabshiftreorder(target_index)
# shift the source to target
source_tab = self.tabs[source_index]
self.tabs[target_index] = source_tab
del self.tabs[source_index]
# first remove the current tab from the dict
oldtab = self.tabs[oldtab_index]
del self.tabs[oldtab_index]
# make newtab_index empty by shifting
tabshiftreorder(newtab_index)
self.tabs[newtab_index] = oldtab
self.current_tab = newtab_index
self.thistab = oldtab
self.ui.titlebar.request_redraw()
self.signal_emit('tab.layoutchange')
def tabshift(self, *args, **kwargs):
return self.tab_shift(*args, **kwargs)
def tab_switch(self, path, create_directory=False):
"""Switches to tab of given path, opening a new tab as necessary.
If path does not exist, it is treated as a directory.
"""
path = realpath(path)
if not os.path.exists(path):
file_selection = None
if create_directory:
try:
if not os.path.isdir(path):
os.makedirs(path)
except OSError as err:
self.fm.notify(err, bad=True)
return
target_directory = path
else:
# Give benefit of the doubt.
potential_parent = os.path.dirname(path)
if os.path.exists(potential_parent) and os.path.isdir(potential_parent):
target_directory = potential_parent
else:
self.fm.notify("Unable to resolve given path.", bad=True)
return
elif os.path.isdir(path):
file_selection = None
target_directory = path
else:
file_selection = path
target_directory = os.path.dirname(path)
for name in self.fm.tabs:
tab = self.fm.tabs[name]
# Is a tab already open?
if tab.path == target_directory:
self.fm.tab_open(name=name)
if file_selection:
self.fm.select_file(file_selection)
return
self.fm.tab_new(path=target_directory)
if file_selection:
self.fm.select_file(file_selection)
def tabswitch(self, *args, **kwargs):
return self.tab_switch(*args, **kwargs)
def get_tab_list(self):
assert self.tabs, "There must be at least 1 tab at all times"
class NaturalOrder(object): # pylint: disable=too-few-public-methods
def __init__(self, obj):
self.obj = obj
def __lt__(self, other):
try:
return self.obj < other.obj
except TypeError:
return str(self.obj) < str(other.obj)
return sorted(self.tabs, key=NaturalOrder)
# --------------------------
# -- Overview of internals
# --------------------------
def _run_pager(self, path):
self.run(shlex.split(os.environ.get('PAGER', ranger.DEFAULT_PAGER)) + [path])
def dump_keybindings(self, *contexts):
if not contexts:
contexts = 'browser', 'console', 'pager', 'taskview'
# Disable lint because TemporaryFiles are removed on close
# pylint: disable=consider-using-with
temporary_file = tempfile.NamedTemporaryFile()
def write(string): # pylint: disable=redefined-outer-name
temporary_file.write(string.encode('utf-8'))
def recurse(before, pointer):
for key, value in pointer.items():
keys = before + [key]
if isinstance(value, dict):
recurse(keys, value)
else:
write("%12s %s\n" % (construct_keybinding(keys), value))
for context in contexts:
write("Keybindings in `%s'\n" % context)
if context in self.fm.ui.keymaps:
recurse([], self.fm.ui.keymaps[context])
else:
write(" None\n")
write("\n")
temporary_file.flush()
self._run_pager(temporary_file.name)
def dump_commands(self):
# Disable lint because TemporaryFiles are removed on close
# pylint: disable=consider-using-with
temporary_file = tempfile.NamedTemporaryFile()
def write(string): # pylint: disable=redefined-outer-name
temporary_file.write(string.encode('utf-8'))
undocumented = []
for cmd_name in sorted(self.commands.commands):
cmd = self.commands.commands[cmd_name]
if hasattr(cmd, '__doc__') and cmd.__doc__:
doc = cleandoc(cmd.__doc__)
if doc[0] == ':':
write(doc)
write("\n\n" + "-" * 60 + "\n")
else:
undocumented.append(cmd)
if undocumented:
write("Undocumented commands:\n\n")
for cmd in undocumented:
write(" :%s\n" % cmd.get_name())
temporary_file.flush()
self._run_pager(temporary_file.name)
def dump_settings(self):
# Disable lint because TemporaryFiles are removed on close
# pylint: disable=consider-using-with
temporary_file = tempfile.NamedTemporaryFile()
def write(string): # pylint: disable=redefined-outer-name
temporary_file.write(string.encode('utf-8'))
for setting in sorted(ALLOWED_SETTINGS):
write("%30s = %s\n" % (setting, getattr(self.settings, setting)))
temporary_file.flush()
self._run_pager(temporary_file.name)
# --------------------------
# -- File System Operations
# --------------------------
def uncut(self):
""":uncut
Empty the copy buffer.
"""
self.copy_buffer = set()
self.do_cut = False
self.ui.browser.main_column.request_redraw()
def copy(self, mode='set', narg=None, dirarg=None):
""":copy [mode=set]
Copy the selected items.
Modes are: 'set', 'add', 'remove'.
"""
assert mode in ('set', 'add', 'remove', 'toggle')
cwd = self.thisdir
if not narg and not dirarg:
selected = (fobj for fobj in self.thistab.get_selection() if fobj in cwd.files)
else:
if not dirarg and narg:
direction = Direction(down=1)
offset = 0
else:
direction = Direction(dirarg)
offset = 1
pos, selected = direction.select(override=narg, lst=cwd.files, current=cwd.pointer,
pagesize=self.ui.termsize[0], offset=offset)
cwd.pointer = pos
cwd.correct_pointer()
if mode == 'set':
self.copy_buffer = set(selected)
elif mode == 'add':
self.copy_buffer.update(set(selected))
elif mode == 'remove':
self.copy_buffer.difference_update(set(selected))
elif mode == 'toggle':
self.copy_buffer.symmetric_difference_update(set(selected))
self.do_cut = False
self.ui.browser.main_column.request_redraw()
def cut(self, mode='set', narg=None, dirarg=None):
""":cut [mode=set]
Cut the selected items.
Modes are: 'set, 'add, 'remove.
"""
self.copy(mode=mode, narg=narg, dirarg=dirarg)
self.do_cut = True
self.ui.browser.main_column.request_redraw()
def paste_symlink(self, relative=False, make_safe_path=get_safe_path):
copied_files = self.copy_buffer
for fobj in copied_files:
new_name = make_safe_path(fobj.basename)
self.notify(new_name)
try:
if relative:
relative_symlink(fobj.path, join(self.fm.thisdir.path, new_name))
else:
symlink(fobj.path, join(self.fm.thisdir.path, new_name))
except OSError as ex:
self.notify('Failed to paste symlink: View log for more info',
bad=True, exception=ex)
def paste_hardlink(self, make_safe_path=get_safe_path):
for fobj in self.copy_buffer:
new_name = make_safe_path(fobj.basename)
try:
link(fobj.path, join(self.fm.thisdir.path, new_name))
except OSError as ex:
self.notify('Failed to paste hardlink: View log for more info',
bad=True, exception=ex)
def paste_hardlinked_subtree(self, make_safe_path=get_safe_path):
for fobj in self.copy_buffer:
try:
target_path = join(self.fm.thisdir.path, fobj.basename)
self._recurse_hardlinked_tree(fobj.path, target_path, make_safe_path)
except OSError as ex:
self.notify('Failed to paste hardlinked subtree: View log for more info',
bad=True, exception=ex)
def _recurse_hardlinked_tree(self, source_path, target_path, make_safe_path):
if isdir(source_path):
if not exists(target_path):
os.mkdir(target_path, stat(source_path).st_mode)
for item in listdir(source_path):
self._recurse_hardlinked_tree(
join(source_path, item),
join(target_path, item),
make_safe_path)
else:
if not exists(target_path) \
or stat(source_path).st_ino != stat(target_path).st_ino:
link(source_path, make_safe_path(target_path))
def paste(self, overwrite=False, append=False, dest=None, make_safe_path=get_safe_path):
""":paste
Paste the selected items into the current directory or to dest
if provided.
"""
if dest is None:
dest = self.thistab.path
if isdir(dest):
loadable = CopyLoader(self.copy_buffer, self.do_cut, overwrite,
dest, make_safe_path)
self.loader.add(loadable, append=append)
self.do_cut = False
else:
self.notify('Failed to paste. The destination is invalid.', bad=True)
def delete(self, files=None):
# XXX: warn when deleting mount points/unseen marked files?
# COMPAT: old command.py use fm.delete() without arguments
if files is None:
files = (fobj.path for fobj in self.thistab.get_selection())
self.notify("Deleting {fls}!".format(fls=", ".join(files)))
files = [os.path.abspath(path) for path in files]
for path in files:
# Untag the deleted files.
for tag in self.fm.tags.tags:
if str(tag).startswith(path):
self.fm.tags.remove(tag)
self.copy_buffer = set(fobj for fobj in self.copy_buffer if fobj.path not in files)
for path in files:
if isdir(path) and not os.path.islink(path):
try:
shutil.rmtree(path)
except OSError as err:
self.notify(err)
else:
try:
os.remove(path)
except OSError as err:
self.notify(err)
self.thistab.ensure_correct_pointer()
def mkdir(self, name):
try:
os.makedirs(os.path.join(self.thisdir.path, name))
except OSError as err:
self.notify(err)
def rename(self, src, dest):
if hasattr(src, 'path'):
src = src.path
try:
os.makedirs(os.path.dirname(dest))
except OSError:
pass
try:
os.rename(src, dest)
except OSError as err:
self.notify(err)
return False
return True
| 59,975 | Python | .py | 1,443 | 29.147609 | 99 | 0.541056 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
764 | filter_stack.py | ranger_ranger/ranger/core/filter_stack.py | # -*- coding: utf-8 -*-
# This file is part of ranger, the console file manager.
# License: GNU GPL version 3, see the file "AUTHORS" for details.
# Author: Wojciech Siewierski <[email protected]>, 2018
from __future__ import (absolute_import, division, print_function)
import re
# pylint: disable=invalid-name
try:
from itertools import izip_longest as zip_longest
except ImportError:
from itertools import zip_longest
# pylint: enable=invalid-name
from os.path import abspath
from ranger.core.shared import FileManagerAware
from ranger.ext.hash import hash_chunks
# pylint: disable=too-few-public-methods
class InodeFilterConstants(object):
DIRS = "d"
FILES = "f"
LINKS = "l"
def accept_file(fobj, filters):
"""
Returns True if file shall be shown, otherwise False.
Parameters:
fobj - an instance of FileSystemObject
filters - an array of lambdas, each expects a fobj and
returns True if fobj shall be shown,
otherwise False.
"""
for filt in filters:
if filt and not filt(fobj):
return False
return True
class BaseFilter(object):
def decompose(self):
return [self]
SIMPLE_FILTERS = {}
FILTER_COMBINATORS = {}
def stack_filter(filter_name):
def decorator(cls):
SIMPLE_FILTERS[filter_name] = cls
return cls
return decorator
def filter_combinator(combinator_name):
def decorator(cls):
FILTER_COMBINATORS[combinator_name] = cls
return cls
return decorator
@stack_filter("name")
class NameFilter(BaseFilter):
def __init__(self, pattern):
self.regex = re.compile(pattern)
def __call__(self, fobj):
return self.regex.search(fobj.relative_path)
def __str__(self):
return "<Filter: name =~ /{pat}/>".format(pat=self.regex.pattern)
@stack_filter("mime")
class MimeFilter(BaseFilter, FileManagerAware):
def __init__(self, pattern):
self.regex = re.compile(pattern)
def __call__(self, fobj):
mimetype, _ = self.fm.mimetypes.guess_type(fobj.relative_path)
if mimetype is None:
return False
return self.regex.search(mimetype)
def __str__(self):
return "<Filter: mimetype =~ /{pat}/>".format(pat=self.regex.pattern)
@stack_filter("hash")
class HashFilter(BaseFilter, FileManagerAware):
def __init__(self, filepath=None):
if filepath is None:
self.filepath = self.fm.thisfile.path
else:
self.filepath = filepath
if self.filepath is None:
self.fm.notify("Error: No file selected for hashing!", bad=True)
# TODO: Lazily generated list would be more efficient, a generator
# isn't enough because this object is reused for every fsobject
# in the current directory.
self.filehash = list(hash_chunks(abspath(self.filepath)))
def __call__(self, fobj):
for (chunk1, chunk2) in zip_longest(self.filehash,
hash_chunks(fobj.path),
fillvalue=''):
if chunk1 != chunk2:
return False
return True
def __str__(self):
return "<Filter: hash {fp}>".format(fp=self.filepath)
def group_by_hash(fsobjects):
hashes = {}
for fobj in fsobjects:
chunks = hash_chunks(fobj.path)
chunk = next(chunks)
while chunk in hashes:
for dup in hashes[chunk]:
_, dup_chunks = dup
try:
hashes[next(dup_chunks)] = [dup]
hashes[chunk].remove(dup)
except StopIteration:
pass
try:
chunk = next(chunks)
except StopIteration:
hashes[chunk].append((fobj, chunks))
break
else:
hashes[chunk] = [(fobj, chunks)]
groups = []
for dups in hashes.values():
group = []
for (dup, _) in dups:
group.append(dup)
if group:
groups.append(group)
return groups
@stack_filter("duplicate")
class DuplicateFilter(BaseFilter, FileManagerAware):
def __init__(self, _):
self.duplicates = self.get_duplicates()
def __call__(self, fobj):
return fobj in self.duplicates
def __str__(self):
return "<Filter: duplicate>"
def get_duplicates(self):
duplicates = set()
for dups in group_by_hash(self.fm.thisdir.files_all):
if len(dups) >= 2:
duplicates.update(dups)
return duplicates
@stack_filter("unique")
class UniqueFilter(BaseFilter, FileManagerAware):
def __init__(self, _):
self.unique = self.get_unique()
def __call__(self, fobj):
return fobj in self.unique
def __str__(self):
return "<Filter: unique>"
def get_unique(self):
unique = set()
for dups in group_by_hash(self.fm.thisdir.files_all):
try:
unique.add(min(dups, key=lambda fobj: fobj.stat.st_ctime))
except ValueError:
pass
return unique
@stack_filter("type")
class TypeFilter(BaseFilter):
type_to_function = {
InodeFilterConstants.DIRS:
(lambda fobj: fobj.is_directory),
InodeFilterConstants.FILES:
(lambda fobj: fobj.is_file and not fobj.is_link),
InodeFilterConstants.LINKS:
(lambda fobj: fobj.is_link),
}
def __init__(self, filetype):
if filetype not in self.type_to_function:
raise KeyError(filetype)
self.filetype = filetype
def __call__(self, fobj):
return self.type_to_function[self.filetype](fobj)
def __str__(self):
return "<Filter: type == '{ft}'>".format(ft=self.filetype)
@filter_combinator("or")
class OrFilter(BaseFilter):
def __init__(self, stack):
self.subfilters = [stack[-2], stack[-1]]
stack.pop()
stack.pop()
stack.append(self)
def __call__(self, fobj):
# Turn logical AND (accept_file()) into a logical OR with the
# De Morgan's laws.
return not accept_file(
fobj,
((lambda x, f=filt: not f(x))
for filt
in self.subfilters),
)
def __str__(self):
return "<Filter: {comp}>".format(
comp=" or ".join(map(str, self.subfilters)))
def decompose(self):
return self.subfilters
@filter_combinator("and")
class AndFilter(BaseFilter):
def __init__(self, stack):
self.subfilters = [stack[-2], stack[-1]]
stack.pop()
stack.pop()
stack.append(self)
def __call__(self, fobj):
return accept_file(fobj, self.subfilters)
def __str__(self):
return "<Filter: {comp}>".format(
comp=" and ".join(map(str, self.subfilters)))
def decompose(self):
return self.subfilters
@filter_combinator("not")
class NotFilter(BaseFilter):
def __init__(self, stack):
self.subfilter = stack.pop()
stack.append(self)
def __call__(self, fobj):
return not self.subfilter(fobj)
def __str__(self):
return "<Filter: not {exp}>".format(exp=str(self.subfilter))
def decompose(self):
return [self.subfilter]
| 7,391 | Python | .tac | 211 | 26.862559 | 77 | 0.604864 | ranger/ranger | 15,344 | 881 | 907 | GPL-3.0 | 9/5/2024, 5:08:02 PM (Europe/Amsterdam) |
765 | setup.py | gak_pycallgraph/setup.py | #!/usr/bin/env python
from os import path
from setuptools import setup
import sys
from setuptools.command.test import test as TestCommand
import pycallgraph
# Only install the man page if the correct directory exists
# XXX: Commented because easy_install doesn't like it
#man_path = '/usr/share/man/man1/'
#if path.exists(man_path):
# data_files=[['/usr/share/man/man1/', ['man/pycallgraph.1']]]
#else:
# data_files=None
data_files=None
class PyTest(TestCommand):
def finalize_options(self):
TestCommand.finalize_options(self)
self.test_args = []
self.test_suite = True
def run_tests(self):
import pytest
errno = pytest.main(self.test_args)
sys.exit(errno)
setup(
name='pycallgraph',
version=pycallgraph.__version__,
description=pycallgraph.__doc__.strip().replace('\n', ' '),
long_description=open('README.rst').read(),
author=pycallgraph.__author__,
author_email=pycallgraph.__email__,
license=open('LICENSE').read(),
url=pycallgraph.__url__,
packages=['pycallgraph', 'pycallgraph.output'],
scripts=['scripts/pycallgraph'],
data_files=data_files,
use_2to3=True,
# TODO: Update download_url
download_url =
'http://pycallgraph.slowchop.com/files/download/pycallgraph-%s.tar.gz' % \
pycallgraph.__version__,
# Testing
tests_require=['pytest'],
cmdclass = {'test': PyTest},
classifiers = [
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: GNU General Public License (GPL)',
'Natural Language :: English',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Topic :: Software Development :: Libraries :: Python Modules',
'Topic :: Software Development :: Testing',
'Topic :: Software Development :: Debuggers',
],
)
| 2,062 | Python | .py | 58 | 30.189655 | 78 | 0.657961 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
766 | conftest.py | gak_pycallgraph/test/conftest.py | import tempfile
from helpers import *
@pytest.fixture(scope='module')
def pycg():
return PyCallGraph()
@pytest.fixture(scope='module')
def config():
return Config()
@pytest.fixture(scope='module')
def temp():
return tempfile.mkstemp()[1]
| 257 | Python | .py | 11 | 20.636364 | 32 | 0.740586 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
767 | test_script.py | gak_pycallgraph/test/test_script.py | import subprocess
from helpers import *
def execute(arguments):
command = 'PYTHONPATH=. scripts/pycallgraph ' + arguments
return subprocess.check_output(command, shell=True).decode('utf-8')
def test_help():
assert 'Python Call Graph' in execute('--help')
def test_graphviz_help():
assert '--font-name FONT_NAME' in execute('graphviz --help')
| 365 | Python | .py | 9 | 37 | 71 | 0.733524 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
768 | fix_path.py | gak_pycallgraph/test/fix_path.py | from os import path
import sys
ROOT = path.join(path.abspath(path.dirname(__file__)), '..')
sys.path.insert(0, ROOT)
| 118 | Python | .py | 4 | 28.25 | 60 | 0.716814 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
769 | test_pycallgraph.py | gak_pycallgraph/test/test_pycallgraph.py | from helpers import *
def test_start_no_outputs(pycg):
with pytest.raises(PyCallGraphException):
pycg.start()
def test_with_block_no_outputs(pycg):
with pytest.raises(PyCallGraphException):
with pycg:
pass
def test_get_tracer_class(pycg):
pycg.config.threaded = True
assert pycg.get_tracer_class() == AsyncronousTracer
pycg.config.threaded = False
assert pycg.get_tracer_class() == SyncronousTracer
| 458 | Python | .py | 13 | 29.692308 | 55 | 0.719178 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
770 | test_color.py | gak_pycallgraph/test/test_color.py | from helpers import *
def test_bad_range():
with pytest.raises(ColorException):
Color(0, 5, 0, 0)
with pytest.raises(ColorException):
Color(0, 0, -1, 0)
def test_hsv():
c = Color.hsv(0.1, 0.5, 0.75, 0.25)
assert c.r is 0.75
assert abs(c.g - 0.6) < 0.1 # Floating point comparison inaccurate
assert abs(c.b - 0.375) < 0.1
assert c.a is 0.25
def test_rgb_csv():
assert Color(0.3, 0.4, 0.5, 0.6).rgb_csv() == '76,102,127'
def test_str():
assert str(Color(0.071, 0.204, 0.338, 0.471)) == '<Color #12345678>'
| 565 | Python | .py | 16 | 30.5625 | 72 | 0.608133 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
771 | test_graphviz.py | gak_pycallgraph/test/test_graphviz.py | from helpers import *
from calls import *
@pytest.fixture
def graphviz(temp):
g = GraphvizOutput()
g.output_file = temp
g.output_type = 'dot'
return g
def test_simple(graphviz):
with PyCallGraph(output=graphviz):
one_nop()
dot = open(graphviz.output_file).read()
os.unlink(graphviz.output_file)
assert 'digraph G' in dot
assert '__main__ -> "calls.one_nop"' in dot
| 414 | Python | .py | 15 | 23.333333 | 47 | 0.677665 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
772 | test_output.py | gak_pycallgraph/test/test_output.py | from helpers import *
def test_set_config():
'''Should not raise!'''
Output().set_config(Config())
| 109 | Python | .py | 4 | 23.75 | 33 | 0.660194 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
773 | test_gephi.py | gak_pycallgraph/test/test_gephi.py | from helpers import *
from calls import *
@pytest.fixture
def gephi(temp):
g = GephiOutput()
g.output_file = temp
return g
def test_simple(gephi):
with PyCallGraph(output=gephi):
one_nop()
generated = open(gephi.output_file).read()
os.unlink(gephi.output_file)
assert 'nodedef> name VARCHAR' in generated
assert 'edgedef> node1 VARCHAR, node2 VARCHAR' in generated
assert 'calls.one_nop,calls.one_nop,calls,1' in generated
assert 'calls.one_nop,calls.nop,1' in generated
| 524 | Python | .py | 16 | 28.4375 | 63 | 0.717694 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
774 | test_util.py | gak_pycallgraph/test/test_util.py | from helpers import *
def test_human_readable_biyte():
hrb = Util.human_readable_bibyte
assert hrb(0) == '0.0B'
assert hrb(1024) == '1.0KiB'
assert hrb(1024 * 5.2) == '5.2KiB'
assert hrb(1024 * 1024 * 5.2) == '5.2MiB'
assert hrb(1024 * 1024 * 1024 * 5.2) == '5.2GiB'
assert hrb(1024 * 1024 * 1024 * 1024 * 5.2) == '5.2TiB'
assert hrb(1024 * 1024 * 1024 * 1024 * 1024 * 5.2) == '5324.8TiB'
assert hrb(-1024 * 1024 * 1024 * 5.2) == '-5.2GiB'
assert hrb(-1024) == '-1.0KiB'
| 513 | Python | .py | 12 | 38.25 | 69 | 0.577154 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
775 | test_config.py | gak_pycallgraph/test/test_config.py | from helpers import *
def test_init():
assert Config().groups
assert Config(groups=False).groups is False
| 116 | Python | .py | 4 | 25.5 | 47 | 0.745455 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
776 | helpers.py | gak_pycallgraph/test/helpers.py | # flake8: noqa
import time
import pytest
import fix_path
from pycallgraph import *
from pycallgraph.tracer import *
from pycallgraph.output import *
def wait_100ms():
time.sleep(0.1)
def wait_200ms():
time.sleep(0.2)
| 231 | Python | .py | 11 | 18.727273 | 32 | 0.775701 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
777 | test_decorators.py | gak_pycallgraph/test/test_decorators.py | import pytest
import pycallgraph
from pycallgraph import PyCallGraphException
from pycallgraph.output import GephiOutput, GraphvizOutput
@pycallgraph.decorators.trace(output=GraphvizOutput())
def print_something():
print("hello")
@pycallgraph.decorators.trace(output=GephiOutput())
def print_foo():
print("foo")
@pycallgraph.decorators.trace()
def print_bar():
print("bar")
def test_trace_decorator_graphviz_output():
print_something()
def test_trace_decorator_gephi_output():
print_foo()
def test_trace_decorator_parameter():
with pytest.raises(PyCallGraphException):
print_bar()
if __name__ == "__main__":
test_trace_decorator_graphviz_output()
test_trace_decorator_gephi_output()
test_trace_decorator_parameter()
| 775 | Python | .py | 24 | 28.833333 | 58 | 0.764946 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
778 | test_trace_processor.py | gak_pycallgraph/test/test_trace_processor.py | import re
import sys
from helpers import *
import calls
from pycallgraph.tracer import TraceProcessor
@pytest.fixture
def trace_processor(config):
return TraceProcessor([], config)
def test_empty(trace_processor):
sys.settrace(trace_processor.process)
sys.settrace(None)
assert trace_processor.call_dict == {}
def test_nop(trace_processor):
sys.settrace(trace_processor.process)
calls.nop()
sys.settrace(None)
assert trace_processor.call_dict == {
'__main__': {
'calls.nop': 1
}
}
def test_one_nop(trace_processor):
sys.settrace(trace_processor.process)
calls.one_nop()
sys.settrace(None)
assert trace_processor.call_dict == {
'__main__': {'calls.one_nop': 1},
'calls.one_nop': {'calls.nop': 1},
}
def stdlib_trace(trace_processor, include_stdlib):
trace_processor.config = Config(include_stdlib=include_stdlib)
sys.settrace(trace_processor.process)
re.match("asdf", "asdf")
calls.one_nop()
sys.settrace(None)
return trace_processor.call_dict
def test_no_stdlib(trace_processor):
assert 're.match' not in stdlib_trace(trace_processor, False)
def test_yes_stdlib(trace_processor):
assert 're.match' in stdlib_trace(trace_processor, True)
| 1,287 | Python | .py | 40 | 27.425 | 66 | 0.702197 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
779 | colors.py | gak_pycallgraph/examples/graphviz/colors.py | #!/usr/bin/env python
'''
This example demonstrates several different methods on colouring your graph.
See U{http://www.graphviz.org/doc/info/attrs.html#k:color} for details on
how to return colour formats to Graphviz.
'''
import random
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph import Color
from pycallgraph.output import GraphvizOutput
def rainbow(node):
'''Colour using only changes in hue.
It will go from 0 to 0.8 which is red, orange, yellow, green, cyan, blue,
then purple.
See http://en.wikipedia.org/wiki/Hue for more information on hue.
'''
return Color.hsv(node.time.fraction * 0.8, 0.4, 0.9)
def greyscale(node):
'''Goes from dark grey to a light grey.'''
return Color.hsv(0, 0, node.time.fraction / 2 + 0.4)
def orange_green(node):
'''Make a higher total time have an orange colour and a higher number
of calls have a green colour using RGB.
'''
return Color(
0.2 + node.time.fraction * 0.8,
0.2 + node.calls.fraction * 0.4 + node.time.fraction * 0.4,
0.2,
)
def rand(node):
return Color.hsv(
random.random(),
node.calls.fraction * 0.5 + 0.5,
node.calls.fraction * 0.5 + 0.5,
)
def main():
graphviz = GraphvizOutput()
pycallgraph = PyCallGraph(
output=graphviz,
config=Config(include_stdlib=True)
)
pycallgraph.start()
import HTMLParser # noqa
pycallgraph.stop()
# Set the edge colour to black for all examples
graphviz.edge_color_func = lambda e: Color(0, 0, 0)
# Default node colouring
graphviz.output_file = 'colours-default.png'
graphviz.done()
def run(func, output_file):
graphviz.node_color_func = func
graphviz.output_file = output_file
graphviz.done()
run(rainbow, 'colors-rainbow.png')
run(greyscale, 'colors-greyscale.png')
run(orange_green, 'colors-orange-green.png')
run(rand, 'colors-random.png')
if __name__ == '__main__':
main()
| 2,037 | Python | .py | 60 | 29 | 77 | 0.678937 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
780 | filter.py | gak_pycallgraph/examples/graphviz/filter.py | #!/usr/bin/env python
'''
This example demonstrates the use of filtering.
'''
import time
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph import GlobbingFilter
from pycallgraph.output import GraphvizOutput
class Banana:
def __init__(self):
pass
def eat(self):
self.secret_function()
self.chew()
self.swallow()
def secret_function(self):
time.sleep(0.2)
def chew(self):
pass
def swallow(self):
pass
def run(name, trace_filter=None, config=None, comment=None):
if not config:
config = Config()
if trace_filter:
config.trace_filter = trace_filter
graphviz = GraphvizOutput()
graphviz.output_file = 'filter-{}.png'.format(name)
if comment:
graphviz.graph_attributes['graph']['label'] = comment
with PyCallGraph(config=config, output=graphviz):
banana = Banana()
banana.eat()
def filter_none():
run(
'none',
comment='Default filtering.'
)
def filter_exclude():
trace_filter = GlobbingFilter(exclude=[
'pycallgraph.*',
'*.secret_function',
])
run(
'exclude',
trace_filter=trace_filter,
comment='Should not include secret_function.',
)
def filter_include():
trace_filter = GlobbingFilter(include=[
'*.secret_function',
'Banana.eat',
])
run(
'include',
trace_filter=trace_filter,
comment='Should show secret_function.'
)
def filter_depth():
config = Config()
config.max_depth = 1
run(
'max_depth',
config=config,
comment='Should only show a depth of one.'
)
def filter_pycallgraph():
trace_filter = GlobbingFilter(exclude=[])
run(
'pycallgraph',
trace_filter=trace_filter,
comment="Don't filter pycallgraph calls.",
)
def main():
filter_none()
filter_exclude()
filter_include()
filter_depth()
filter_pycallgraph()
if __name__ == '__main__':
main()
| 2,083 | Python | .py | 82 | 19.439024 | 61 | 0.628934 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
781 | large.py | gak_pycallgraph/examples/graphviz/large.py | #!/usr/bin/env python
'''
This example is trying to make a large graph. You'll need some internet access
for this to work.
'''
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph.output import GraphvizOutput
def main():
graphviz = GraphvizOutput()
graphviz.output_file = 'large.png'
config = Config(include_stdlib=True)
with PyCallGraph(output=graphviz, config=config):
from urllib2 import urlopen
from xml.dom.minidom import parseString
parseString(urlopen('http://w3.org/').read())
if __name__ == '__main__':
main()
| 600 | Python | .py | 18 | 29.555556 | 78 | 0.727431 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
782 | regexp.py | gak_pycallgraph/examples/graphviz/regexp.py | #!/usr/bin/env python
'''
This example demonstrates the internal workings of a regular expression lookup.
'''
import re
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph.output import GraphvizOutput
def main():
graphviz = GraphvizOutput()
graphviz.output_file = 'regexp.png'
config = Config(include_stdlib=True)
with PyCallGraph(output=graphviz, config=config):
reo = compile()
match(reo)
def compile():
return re.compile('^[abetors]*$')
def match(reo):
[reo.match(a) for a in words()]
def words():
return [
'abbreviation',
'abbreviations',
'abettor',
'abettors',
'abilities',
'ability',
'abrasion',
'abrasions',
'abrasive',
'abrasives',
]
if __name__ == '__main__':
main()
| 851 | Python | .py | 34 | 19.823529 | 79 | 0.640199 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
783 | basic.py | gak_pycallgraph/examples/graphviz/basic.py | #!/usr/bin/env python
'''
This example demonstrates a simple use of pycallgraph.
'''
from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput
class Banana:
def eat(self):
pass
class Person:
def __init__(self):
self.no_bananas()
def no_bananas(self):
self.bananas = []
def add_banana(self, banana):
self.bananas.append(banana)
def eat_bananas(self):
[banana.eat() for banana in self.bananas]
self.no_bananas()
def main():
graphviz = GraphvizOutput()
graphviz.output_file = 'basic.png'
with PyCallGraph(output=graphviz):
person = Person()
for a in xrange(10):
person.add_banana(Banana())
person.eat_bananas()
if __name__ == '__main__':
main()
| 800 | Python | .py | 29 | 21.965517 | 54 | 0.64465 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
784 | all.py | gak_pycallgraph/examples/graphviz/all.py | #!/usr/bin/env python
'''
Execute all pycallgraph examples in this directory.
'''
from glob import glob
examples = glob('*.py')
examples.remove('all.py')
for example in examples:
print(example)
execfile(example)
| 222 | Python | .py | 10 | 20.2 | 51 | 0.747619 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
785 | grouper.py | gak_pycallgraph/examples/graphviz/grouper.py | #!/usr/bin/env python
'''
This example demonstrates the use of grouping.
'''
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph import GlobbingFilter
from pycallgraph import Grouper
from pycallgraph.output import GraphvizOutput
import example_with_submodules
def run(name, trace_grouper=None, config=None, comment=None):
if not config:
config = Config()
config.trace_filter = GlobbingFilter()
if trace_grouper is not None:
config.trace_grouper = trace_grouper
graphviz = GraphvizOutput()
graphviz.output_file = 'grouper-{}.png'.format(name)
if comment:
graphviz.graph_attributes['graph']['label'] = comment
with PyCallGraph(config=config, output=graphviz):
example_with_submodules.main()
def group_none():
run(
'without',
comment='Default grouping.'
)
def group_some():
trace_grouper = Grouper(groups=[
'example_with_submodules.submodule_one.*',
'example_with_submodules.submodule_two.*',
'example_with_submodules.helpers.*',
])
run(
'with',
trace_grouper=trace_grouper,
comment='Should assign groups to the two submodules.',
)
def group_methods():
trace_grouper = Grouper(groups=[
'example_with_submodules.*.report',
])
run(
'methods',
trace_grouper=trace_grouper,
comment='Should assign a group to the report methods.',
)
def main():
group_none()
group_some()
group_methods()
if __name__ == '__main__':
main()
| 1,579 | Python | .py | 53 | 24.377358 | 63 | 0.674403 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
786 | import.py | gak_pycallgraph/examples/graphviz/import.py | #!/usr/bin/env python
'''
This example shows the interals of certain Python modules when they are being
imported.
'''
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph.output import GraphvizOutput
def main():
import_list = (
'pickle',
'htmllib',
'urllib2',
)
graphviz = GraphvizOutput()
config = Config(include_stdlib=True)
for module in import_list:
graphviz.output_file = 'import-{}.png'.format(module)
with PyCallGraph(output=graphviz, config=config):
__import__(module)
if __name__ == '__main__':
main()
| 623 | Python | .py | 22 | 23.636364 | 77 | 0.676174 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
787 | recursive.py | gak_pycallgraph/examples/graphviz/recursive.py | #!/usr/bin/env python
'''
This example demonstrates a simple recursive call.
'''
from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput
def factorial(n):
if n == 1:
return 1
return n * factorial(n - 1)
def main():
graphviz = GraphvizOutput()
graphviz.output_file = 'recursive.png'
with PyCallGraph(output=graphviz):
for a in xrange(1, 10):
factorial(a)
if __name__ == '__main__':
main()
| 472 | Python | .py | 18 | 22 | 50 | 0.669643 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
788 | submodule_two.py | gak_pycallgraph/examples/graphviz/example_with_submodules/submodule_two.py | from helpers import helper
class SubmoduleTwo(object):
def __init__(self):
self.two = 2
def report(self):
return helper(self.two)
| 157 | Python | .py | 6 | 20.666667 | 31 | 0.655405 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
789 | example_with_submodules.py | gak_pycallgraph/examples/graphviz/example_with_submodules/example_with_submodules.py | from submodule_one import SubmoduleOne
from submodule_two import SubmoduleTwo
def main():
s1 = SubmoduleOne()
s1.report()
s2 = SubmoduleTwo()
s2.report()
if __name__ == "__main__":
main()
| 212 | Python | .py | 9 | 19.888889 | 38 | 0.668342 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
790 | submodule_one.py | gak_pycallgraph/examples/graphviz/example_with_submodules/submodule_one.py | class SubmoduleOne(object):
def __init__(self):
self.one = 1
def report(self):
return self.one
| 120 | Python | .py | 5 | 18 | 27 | 0.596491 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
791 | large.py | gak_pycallgraph/examples/gephi/large.py | #!/usr/bin/env python
'''
This example is trying to make a large graph. You'll need some internet access
for this to work.
'''
from pycallgraph import PyCallGraph
from pycallgraph.output import GephiOutput
def main():
gephi = GephiOutput()
gephi.output_file = 'large.gdf'
with PyCallGraph(output=gephi):
from urllib2 import urlopen
from xml.dom.minidom import parseString
parseString(urlopen('http://w3.org/').read())
if __name__ == '__main__':
main()
| 498 | Python | .py | 16 | 27.25 | 78 | 0.705882 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
792 | basic.py | gak_pycallgraph/examples/gephi/basic.py | #!/usr/bin/env python
'''
This example demonstrates a simple use of pycallgraph.
'''
from pycallgraph import PyCallGraph
from pycallgraph.output import GephiOutput
class Banana:
def eat(self):
pass
class Person:
def __init__(self):
self.no_bananas()
def no_bananas(self):
self.bananas = []
def add_banana(self, banana):
self.bananas.append(banana)
def eat_bananas(self):
[banana.eat() for banana in self.bananas]
self.no_bananas()
def main():
gephi = GephiOutput()
gephi.output_file = 'basic.gdf'
with PyCallGraph(output=gephi):
person = Person()
for a in xrange(10):
person.add_banana(Banana())
person.eat_bananas()
if __name__ == '__main__':
main()
| 785 | Python | .py | 29 | 21.448276 | 54 | 0.637466 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
793 | all.py | gak_pycallgraph/examples/gephi/all.py | #!/usr/bin/env python
'''
Execute all pycallgraph examples in this directory.
'''
from glob import glob
examples = glob('*.py')
examples.remove('all.py')
for example in examples:
print(example)
execfile(example)
| 222 | Python | .py | 10 | 20.2 | 51 | 0.747619 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
794 | update_readme.py | gak_pycallgraph/docs/update_readme.py | #!/usr/bin/env python
'''
This script copies the index.rst page from the Sphinx documentation, modifies
it slightly so refs point to the correct place.
'''
import re
import os
import sys
import shutil
class GithubReadmeMaker(object):
def __init__(self):
self.root = os.path.abspath(os.path.dirname(__file__))
os.chdir(self.root)
def run(self):
self.copy()
rst = open('../README.rst').read()
rst = self.fix_links(rst)
rst = self.fix_index(rst)
open('../README.rst', 'w').write(rst)
def copy(self):
shutil.copy('index.rst', '../README.rst')
def fix_links(self, rst):
prefix = 'http://pycallgraph.slowchop.com/en/develop'
rst = rst.replace(
':ref:`command-line interface <command_line_usage>`',
'`command-line interface <{}/guide/command_line_usage.html>`_'
.format(prefix)
)
rst = rst.replace(
':ref:`pycallgraph module <pycallgraph>`',
'`pycallgraph module <{}/api/pycallgraph.html>`_'.format(prefix)
)
# Thumbnail URL
rst = re.sub(
r'image:: examples/(.*_thumb)',
r'image:: {}/_images/\g<1>'.format(prefix),
rst,
)
rst = re.sub(
r'target: (examples/.*)',
r'target: {}/\g<1>'.format(prefix),
rst,
)
return rst
def fix_index(self, rst):
docidx_offset = rst.find('Documentation Index')
rst = rst[:docidx_offset]
rst += open('readme_extras.rst').read()
return rst
if __name__ == '__main__':
GithubReadmeMaker().run()
| 1,666 | Python | .py | 51 | 24.745098 | 77 | 0.563046 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
795 | conf.py | gak_pycallgraph/docs/conf.py | # -*- coding: utf-8 -*-
#
# Python Call Graph documentation build configuration file, created by
# sphinx-quickstart on Wed Jul 24 17:23:48 2013.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('..'))
import pycallgraph
# -- General configuration -----------------------------------------------------
todo_include_todos = True
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.coverage', 'sphinx.ext.viewcode']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Python Call Graph'
copyright = u'2007-2013 Gerald Kaszuba, et al.'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = pycallgraph.__version__
# The full version, including alpha/beta/rc tags.
release = pycallgraph.__version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'PythonCallGraphdoc'
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'PythonCallGraph.tex', u'Python Call Graph',
u'Gerald Kaszuba', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('guide/command_line_usage', 'pycallgraph', u'Python Call Graph',
['''pycallgraph was written by Gerald Kaszuba <[email protected]>.
This manual page was originally written by Jan Alonzo <[email protected]>, for the Debian GNU/Linux system.
'''], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output ------------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'PythonCallGraph', u'Python Call Graph',
u'Gerald Kaszuba', 'PythonCallGraph', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
| 8,350 | Python | .py | 185 | 43.643243 | 114 | 0.731349 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
796 | generate.py | gak_pycallgraph/docs/examples/generate.py | #!/usr/bin/env python
import hashlib
import subprocess
import yaml
INDEX_TEMPLATE = '''
Examples
========
.. toctree::
:maxdepth: 3
{}
'''
IMAGE_TEMPLATE = '''
.. _{0[name]}_example:
{0[title]}
===================
{0[description]}
Source Code
-----------
.. literalinclude:: {0[script]}
Generated Image
---------------
Below is the generated image from the code above. If you're having issues with the image below, try the :download:`direct link to image <{0[name]}.png>`.
.. container:: example-image
.. image:: {0[name]}.png
:target: ../_downloads/{0[name]}.png
'''
index = []
new_yaml = []
for info in yaml.load(open('examples.yml')):
new_info = info
new_yaml.append(new_info)
index.append(info['name'])
# Generate the rst for this example
open('{}.rst'.format(info['name']), 'w').write(
IMAGE_TEMPLATE.format(info).strip()
)
print(info['run'])
# If the hash of the example hasn't changed, don't run again
filemd5 = hashlib.md5(open(info['script']).read()).hexdigest()
if filemd5 != info.get('md5'):
info['md5'] = filemd5
subprocess.call(info['run'], shell=True)
if 'execute_after' in info:
print('Running {}'.format(info['execute_after']))
subprocess.call(info['execute_after'], shell=True)
open('index.rst', 'w').write(INDEX_TEMPLATE.format('\n '.join(index)))
out = yaml.dump(new_yaml, default_flow_style=False)
open('examples.yml', 'w').write(out)
| 1,501 | Python | .py | 48 | 27.270833 | 153 | 0.628953 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
797 | regexp.py | gak_pycallgraph/docs/examples/regexp.py | #!/usr/bin/env python
'''
Runs a regular expression over the first few hundred words in a dictionary to
find if any words start and end with the same letter, and having two of the
same letters in a row.
'''
import argparse
import re
from pycallgraph import PyCallGraph
from pycallgraph import Config
from pycallgraph.output import GraphvizOutput
class RegExp(object):
def main(self):
parser = argparse.ArgumentParser()
parser.add_argument('--grouped', action='store_true')
conf = parser.parse_args()
if conf.grouped:
self.run('regexp_grouped.png', Config(groups=True))
else:
self.run('regexp_ungrouped.png', Config(groups=False))
def run(self, output, config):
graphviz = GraphvizOutput()
graphviz.output_file = output
self.expression = r'^([^s]).*(.)\2.*\1$'
with PyCallGraph(config=config, output=graphviz):
self.precompiled()
self.onthefly()
def words(self):
a = 200
for word in open('/usr/share/dict/words'):
yield word.strip()
a -= 1
if not a:
return
def precompiled(self):
reo = re.compile(self.expression)
for word in self.words():
reo.match(word)
def onthefly(self):
for word in self.words():
re.match(self.expression, word)
if __name__ == '__main__':
RegExp().main()
| 1,449 | Python | .py | 43 | 26.348837 | 77 | 0.623833 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
798 | basic.py | gak_pycallgraph/docs/examples/basic.py | #!/usr/bin/env python
'''
This example demonstrates a simple use of pycallgraph.
'''
from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput
class Banana:
def eat(self):
pass
class Person:
def __init__(self):
self.no_bananas()
def no_bananas(self):
self.bananas = []
def add_banana(self, banana):
self.bananas.append(banana)
def eat_bananas(self):
[banana.eat() for banana in self.bananas]
self.no_bananas()
def main():
graphviz = GraphvizOutput()
graphviz.output_file = 'basic.png'
with PyCallGraph(output=graphviz):
person = Person()
for a in xrange(10):
person.add_banana(Banana())
person.eat_bananas()
if __name__ == '__main__':
main()
| 800 | Python | .py | 29 | 21.965517 | 54 | 0.64465 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
799 | generate.py | gak_pycallgraph/docs/guide/filtering/generate.py | #!/usr/bin/env python
import hashlib
import subprocess
import yaml
items = yaml.load(open('examples.yml'))
print(items)
changed = False
for script, save_md5 in items.iteritems():
new_md5 = hashlib.md5(open(script).read()).hexdigest()
if new_md5 == save_md5:
continue
changed = True
items[script] = new_md5
subprocess.call('./{}'.format(script), shell=True)
if changed:
open('examples.yml', 'w').write(yaml.dump(items))
| 458 | Python | .py | 16 | 25.1875 | 58 | 0.698851 | gak/pycallgraph | 1,816 | 335 | 61 | GPL-2.0 | 9/5/2024, 5:08:15 PM (Europe/Amsterdam) |
Subsets and Splits