thefuck-leeguoo 3.41__py2.py3-none-any.whl

thefuck/logs.py

@@ -0,0 +1,255 @@
+# -*- encoding: utf-8 -*-
+
+from contextlib import contextmanager
+from datetime import datetime
+import os
+import re
+import sys
+import unicodedata
+from traceback import format_exception
+import colorama
+try:
+    from shutil import get_terminal_size
+except ImportError:  # pragma: no cover - Python < 3.3
+    from backports.shutil_get_terminal_size import get_terminal_size
+from .conf import settings
+from . import const
+
+
+def color(color_):
+    """Utility for ability to disabling colored output."""
+    if settings.no_colors:
+        return ''
+    else:
+        return color_
+
+
+_ANSI_RE = re.compile(r'\x1b\[[0-?]*[ -/]*[@-~]')
+_last_confirm_lines = 0
+
+
+def _strip_ansi(text):
+    return _ANSI_RE.sub('', text)
+
+
+def _terminal_columns():
+    try:
+        return os.get_terminal_size(sys.stderr.fileno()).columns or 80
+    except Exception:
+        cols = get_terminal_size((80, 20)).columns or 80
+        return cols
+
+
+def _text_width(text):
+    width = 0
+    for ch in text:
+        if unicodedata.combining(ch):
+            continue
+        if unicodedata.east_asian_width(ch) in ('W', 'F'):
+            width += 2
+        else:
+            width += 1
+    return width
+
+
+def _calc_prompt_lines(text):
+    cols = _terminal_columns()
+    if cols <= 0:
+        cols = 80
+    visible = _strip_ansi(text.replace(const.USER_COMMAND_MARK, ''))
+    if not visible:
+        return 1
+    total = 0
+    for line in visible.splitlines() or ['']:
+        width = _text_width(line)
+        total += max(1, (width - 1) // cols + 1)
+    return total
+
+
+def _clear_previous_confirm():
+    if _last_confirm_lines <= 0:
+        return ''
+    seq = '\r'
+    for idx in range(_last_confirm_lines):
+        seq += '\033[2K'
+        if idx < _last_confirm_lines - 1:
+            seq += '\033[1A'
+    return seq + '\r'
+
+
+def reset_confirm_text():
+    global _last_confirm_lines
+    _last_confirm_lines = 0
+
+
+def warn(title):
+    sys.stderr.write(u'{warn}[WARN] {title}{reset}\n'.format(
+        warn=color(colorama.Back.RED + colorama.Fore.WHITE
+                   + colorama.Style.BRIGHT),
+        reset=color(colorama.Style.RESET_ALL),
+        title=title))
+
+
+def exception(title, exc_info):
+    sys.stderr.write(
+        u'{warn}[WARN] {title}:{reset}\n{trace}'
+        u'{warn}----------------------------{reset}\n\n'.format(
+            warn=color(colorama.Back.RED + colorama.Fore.WHITE
+                       + colorama.Style.BRIGHT),
+            reset=color(colorama.Style.RESET_ALL),
+            title=title,
+            trace=''.join(format_exception(*exc_info))))
+
+
+def rule_failed(rule, exc_info):
+    exception(u'Rule {}'.format(rule.name), exc_info)
+
+
+def failed(msg):
+    sys.stderr.write(u'{red}{msg}{reset}\n'.format(
+        msg=msg,
+        red=color(colorama.Fore.RED),
+        reset=color(colorama.Style.RESET_ALL)))
+
+
+def show_corrected_command(corrected_command):
+    desc = getattr(corrected_command, 'desc', '') or ''
+    desc = u' '.join(desc.split())
+    desc_output = ''
+    if desc:
+        desc_output = u' — {desc_color}{desc}{reset}'.format(
+            desc_color=color(colorama.Fore.YELLOW),
+            desc=desc,
+            reset=color(colorama.Style.RESET_ALL))
+    sys.stderr.write(
+        u'{prefix}{cmd_color}{script}{reset}{desc_output}{side_effect}\n'.format(
+            prefix=const.USER_COMMAND_MARK,
+            script=corrected_command.script,
+            desc_output=desc_output,
+            side_effect=u' (+side effect)' if corrected_command.side_effect else u'',
+            cmd_color=color(colorama.Style.BRIGHT + colorama.Fore.CYAN),
+            reset=color(colorama.Style.RESET_ALL)))
+
+
+def confirm_text(corrected_command):
+    global _last_confirm_lines
+    desc = getattr(corrected_command, 'desc', '') or ''
+    desc = u' '.join(desc.split())
+    desc_output = ''
+    if desc:
+        desc_output = u' — {desc_color}{desc}{reset}'.format(
+            desc_color=color(colorama.Fore.YELLOW),
+            desc=desc,
+            reset=color(colorama.Style.RESET_ALL))
+    prompt = (u'{prefix}{cmd_color}{script}{reset}{desc_output}{side_effect} '
+              u'[{green}enter{reset}/{blue}↑{reset}/{blue}↓{reset}'
+              u'/{blue}tab{reset}/{red}ctrl+c{reset}]').format(
+                  prefix=const.USER_COMMAND_MARK,
+                  script=corrected_command.script,
+                  desc_output=desc_output,
+                  side_effect=' (+side effect)' if corrected_command.side_effect else '',
+                  cmd_color=color(colorama.Style.BRIGHT + colorama.Fore.CYAN),
+                  green=color(colorama.Fore.GREEN),
+                  red=color(colorama.Fore.RED),
+                  reset=color(colorama.Style.RESET_ALL),
+                  blue=color(colorama.Fore.BLUE))
+    sys.stderr.write(_clear_previous_confirm())
+    sys.stderr.write(prompt)
+    sys.stderr.flush()
+    _last_confirm_lines = _calc_prompt_lines(prompt)
+
+
+def ai_choose_header():
+    sys.stderr.write(u'\n{label}Choose{reset}\n'.format(
+        label=color(colorama.Style.BRIGHT + colorama.Fore.GREEN),
+        reset=color(colorama.Style.RESET_ALL)))
+
+
+def confirm_choice(corrected_command):
+    global _last_confirm_lines
+    index = getattr(corrected_command, '_tf_index', None)
+    if not index:
+        return confirm_text(corrected_command)
+    prompt = (u'{prefix}{bold}{index}{reset} '
+              u'[{green}enter{reset}/{blue}↑{reset}/{blue}↓{reset}'
+              u'/{blue}tab{reset}/{red}ctrl+c{reset}]').format(
+                  prefix=const.USER_COMMAND_MARK,
+                  index=index,
+                  bold=color(colorama.Style.BRIGHT),
+                  green=color(colorama.Fore.GREEN),
+                  red=color(colorama.Fore.RED),
+                  reset=color(colorama.Style.RESET_ALL),
+                  blue=color(colorama.Fore.BLUE))
+    sys.stderr.write(_clear_previous_confirm())
+    sys.stderr.write(prompt)
+    sys.stderr.flush()
+    _last_confirm_lines = _calc_prompt_lines(prompt)
+
+
+def debug(msg):
+    if settings.debug:
+        sys.stderr.write(u'{blue}{bold}DEBUG:{reset} {msg}\n'.format(
+            msg=msg,
+            reset=color(colorama.Style.RESET_ALL),
+            blue=color(colorama.Fore.BLUE),
+            bold=color(colorama.Style.BRIGHT)))
+
+
+@contextmanager
+def debug_time(msg):
+    started = datetime.now()
+    try:
+        yield
+    finally:
+        debug(u'{} took: {}'.format(msg, datetime.now() - started))
+
+
+def how_to_configure_alias(configuration_details):
+    print(u"Seems like {bold}fuck{reset} alias isn't configured!".format(
+        bold=color(colorama.Style.BRIGHT),
+        reset=color(colorama.Style.RESET_ALL)))
+
+    if configuration_details:
+        print(
+            u"Please put {bold}{content}{reset} in your "
+            u"{bold}{path}{reset} and apply "
+            u"changes with {bold}{reload}{reset} or restart your shell.".format(
+                bold=color(colorama.Style.BRIGHT),
+                reset=color(colorama.Style.RESET_ALL),
+                **configuration_details._asdict()))
+
+        if configuration_details.can_configure_automatically:
+            print(
+                u"Or run {bold}fuck{reset} a second time to configure"
+                u" it automatically.".format(
+                    bold=color(colorama.Style.BRIGHT),
+                    reset=color(colorama.Style.RESET_ALL)))
+
+    print(u'More details - https://github.com/nvbn/thefuck#manual-installation')
+
+
+def already_configured(configuration_details):
+    print(
+        u"Seems like {bold}fuck{reset} alias already configured!\n"
+        u"For applying changes run {bold}{reload}{reset}"
+        u" or restart your shell.".format(
+            bold=color(colorama.Style.BRIGHT),
+            reset=color(colorama.Style.RESET_ALL),
+            reload=configuration_details.reload))
+
+
+def configured_successfully(configuration_details):
+    print(
+        u"{bold}fuck{reset} alias configured successfully!\n"
+        u"For applying changes run {bold}{reload}{reset}"
+        u" or restart your shell.".format(
+            bold=color(colorama.Style.BRIGHT),
+            reset=color(colorama.Style.RESET_ALL),
+            reload=configuration_details.reload))
+
+
+def version(thefuck_version, python_version, shell_info):
+    sys.stderr.write(
+        u'The Fuck {} using Python {} and {}\n'.format(thefuck_version,
+                                                       python_version,
+                                                       shell_info))

thefuck/output_readers/__init__.py

@@ -0,0 +1,20 @@
+from ..conf import settings
+from . import read_log, rerun, shell_logger
+
+
+def get_output(script, expanded):
+    """Get output of the script.
+
+    :param script: Console script.
+    :type script: str
+    :param expanded: Console script with expanded aliases.
+    :type expanded: str
+    :rtype: str
+
+    """
+    if shell_logger.is_available():
+        return shell_logger.get_output(script)
+    if settings.instant_mode:
+        return read_log.get_output(script)
+    else:
+        return rerun.get_output(script, expanded)

thefuck/output_readers/read_log.py

@@ -0,0 +1,108 @@
+import os
+import shlex
+import mmap
+import re
+try:
+    from shutil import get_terminal_size
+except ImportError:
+    from backports.shutil_get_terminal_size import get_terminal_size
+import six
+import pyte
+from ..exceptions import ScriptNotInLog
+from .. import const, logs
+
+
+def _group_by_calls(log):
+    ps1 = os.environ['PS1']
+    ps1_newlines = ps1.count('\\n') + ps1.count('\n')
+    ps1_counter = 0
+
+    script_line = None
+    lines = []
+    for line in log:
+        if const.USER_COMMAND_MARK in line or ps1_counter > 0:
+            if script_line and ps1_counter == 0:
+                yield script_line, lines
+
+            if ps1_newlines > 0:
+                if ps1_counter <= 0:
+                    ps1_counter = ps1_newlines
+                else:
+                    ps1_counter -= 1
+
+            script_line = line
+            lines = [line]
+        elif script_line is not None:
+            lines.append(line)
+
+    if script_line:
+        yield script_line, lines
+
+
+def _get_script_group_lines(grouped, script):
+    if six.PY2:
+        script = script.encode('utf-8')
+
+    parts = shlex.split(script)
+
+    for script_line, lines in reversed(grouped):
+        if all(part in script_line for part in parts):
+            return lines
+
+    raise ScriptNotInLog
+
+
+def _get_output_lines(script, log_file):
+    data = log_file.read().decode()
+    data = re.sub(r'\x00+$', '', data)
+    lines = data.split('\n')
+    grouped = list(_group_by_calls(lines))
+    script_lines = _get_script_group_lines(grouped, script)
+    screen = pyte.Screen(get_terminal_size().columns, len(script_lines))
+    stream = pyte.Stream(screen)
+    stream.feed('\n'.join(script_lines))
+    return screen.display
+
+
+def _skip_old_lines(log_file):
+    size = os.path.getsize(os.environ['THEFUCK_OUTPUT_LOG'])
+    if size > const.LOG_SIZE_IN_BYTES:
+        log_file.seek(size - const.LOG_SIZE_IN_BYTES)
+
+
+def get_output(script):
+    """Reads script output from log.
+
+    :type script: str
+    :rtype: str | None
+
+    """
+    if six.PY2:
+        logs.warn('Experimental instant mode is Python 3+ only')
+        return None
+
+    if 'THEFUCK_OUTPUT_LOG' not in os.environ:
+        logs.warn("Output log isn't specified")
+        return None
+
+    if const.USER_COMMAND_MARK not in os.environ.get('PS1', ''):
+        logs.warn(
+            "PS1 doesn't contain user command mark, please ensure "
+            "that PS1 is not changed after The Fuck alias initialization")
+        return None
+
+    try:
+        with logs.debug_time(u'Read output from log'):
+            fd = os.open(os.environ['THEFUCK_OUTPUT_LOG'], os.O_RDONLY)
+            buffer = mmap.mmap(fd, const.LOG_SIZE_IN_BYTES, mmap.MAP_SHARED, mmap.PROT_READ)
+            _skip_old_lines(buffer)
+            lines = _get_output_lines(script, buffer)
+            output = '\n'.join(lines).strip()
+            logs.debug(u'Received output: {}'.format(output))
+            return output
+    except OSError:
+        logs.warn("Can't read output log")
+        return None
+    except ScriptNotInLog:
+        logs.warn("Script not found in output log")
+        return None

thefuck/output_readers/rerun.py

@@ -0,0 +1,72 @@
+import os
+import shlex
+import six
+from subprocess import Popen, PIPE, STDOUT
+from psutil import AccessDenied, Process, TimeoutExpired
+from .. import logs
+from ..conf import settings
+
+
+def _kill_process(proc):
+    """Tries to kill the process otherwise just logs a debug message, the
+    process will be killed when thefuck terminates.
+
+    :type proc: Process
+
+    """
+    try:
+        proc.kill()
+    except AccessDenied:
+        logs.debug(u'Rerun: process PID {} ({}) could not be terminated'.format(
+            proc.pid, proc.exe()))
+
+
+def _wait_output(popen, is_slow):
+    """Returns `True` if we can get output of the command in the
+    `settings.wait_command` time.
+
+    Command will be killed if it wasn't finished in the time.
+
+    :type popen: Popen
+    :rtype: bool
+
+    """
+    proc = Process(popen.pid)
+    try:
+        proc.wait(settings.wait_slow_command if is_slow
+                  else settings.wait_command)
+        return True
+    except TimeoutExpired:
+        for child in proc.children(recursive=True):
+            _kill_process(child)
+        _kill_process(proc)
+        return False
+
+
+def get_output(script, expanded):
+    """Runs the script and obtains stdin/stderr.
+
+    :type script: str
+    :type expanded: str
+    :rtype: str | None
+
+    """
+    env = dict(os.environ)
+    env.update(settings.env)
+
+    if six.PY2:
+        expanded = expanded.encode('utf-8')
+
+    split_expand = shlex.split(expanded)
+    is_slow = split_expand[0] in settings.slow_commands if split_expand else False
+    with logs.debug_time(u'Call: {}; with env: {}; is slow: {}'.format(
+            script, env, is_slow)):
+        result = Popen(expanded, shell=True, stdin=PIPE,
+                       stdout=PIPE, stderr=STDOUT, env=env)
+        if _wait_output(result, is_slow):
+            output = result.stdout.read().decode('utf-8', errors='replace')
+            logs.debug(u'Received output: {}'.format(output))
+            return output
+        else:
+            logs.debug(u'Execution timed out!')
+            return None

thefuck/output_readers/shell_logger.py

@@ -0,0 +1,60 @@
+import json
+import os
+import socket
+try:
+    from shutil import get_terminal_size
+except ImportError:
+    from backports.shutil_get_terminal_size import get_terminal_size
+import pyte
+from .. import const, logs
+
+
+def _get_socket_path():
+    return os.environ.get(const.SHELL_LOGGER_SOCKET_ENV)
+
+
+def is_available():
+    """Returns `True` if shell logger socket available.
+
+    :rtype: book
+
+    """
+    path = _get_socket_path()
+    if not path:
+        return False
+
+    return os.path.exists(path)
+
+
+def _get_last_n(n):
+    with socket.socket(socket.AF_UNIX) as client:
+        client.connect(_get_socket_path())
+        request = json.dumps({
+            "type": "list",
+            "count": n,
+        }) + '\n'
+        client.sendall(request.encode('utf-8'))
+        response = client.makefile().readline()
+        return json.loads(response)['commands']
+
+
+def _get_output_lines(output):
+    lines = output.split('\n')
+    screen = pyte.Screen(get_terminal_size().columns, len(lines))
+    stream = pyte.Stream(screen)
+    stream.feed('\n'.join(lines))
+    return screen.display
+
+
+def get_output(script):
+    """Gets command output from shell logger."""
+    with logs.debug_time(u'Read output from external shell logger'):
+        commands = _get_last_n(const.SHELL_LOGGER_LIMIT)
+        for command in commands:
+            if command['command'] == script:
+                lines = _get_output_lines(command['output'])
+                output = '\n'.join(lines).strip()
+                return output
+            else:
+                logs.warn("Output isn't available in shell logger")
+                return None

thefuck/rules/adb_unknown_command.py

@@ -0,0 +1,54 @@
+from thefuck.utils import is_app, get_closest, replace_argument
+
+
+_ADB_COMMANDS = (
+    'backup',
+    'bugreport',
+    'connect',
+    'devices',
+    'disable-verity',
+    'disconnect',
+    'enable-verity',
+    'emu',
+    'forward',
+    'get-devpath',
+    'get-serialno',
+    'get-state',
+    'install',
+    'install-multiple',
+    'jdwp',
+    'keygen',
+    'kill-server',
+    'logcat',
+    'pull',
+    'push',
+    'reboot',
+    'reconnect',
+    'restore',
+    'reverse',
+    'root',
+    'run-as',
+    'shell',
+    'sideload',
+    'start-server',
+    'sync',
+    'tcpip',
+    'uninstall',
+    'unroot',
+    'usb',
+    'wait-for',
+)
+
+
+def match(command):
+    return (is_app(command, 'adb')
+            and command.output.startswith('Android Debug Bridge version'))
+
+
+def get_new_command(command):
+    for idx, arg in enumerate(command.script_parts[1:]):
+        # allowed params to ADB are a/d/e/s/H/P/L where s, H, P and L take additional args
+        # for example 'adb -s 111 logcat' or 'adb -e logcat'
+        if not arg[0] == '-' and not command.script_parts[idx] in ('-s', '-H', '-P', '-L'):
+            adb_cmd = get_closest(arg, _ADB_COMMANDS)
+            return replace_argument(command.script, arg, adb_cmd)

thefuck/rules/ag_literal.py

@@ -0,0 +1,10 @@
+from thefuck.utils import for_app
+
+
+@for_app('ag')
+def match(command):
+    return command.output.endswith('run ag with -Q\n')
+
+
+def get_new_command(command):
+    return command.script.replace('ag', 'ag -Q', 1)

thefuck/rules/apt_get.py

@@ -0,0 +1,50 @@
+from types import ModuleType
+from thefuck.specific.apt import apt_available
+from thefuck.utils import memoize, which
+from thefuck.shells import shell
+
+try:
+    from CommandNotFound import CommandNotFound
+
+    enabled_by_default = apt_available
+
+    if isinstance(CommandNotFound, ModuleType):
+        # For ubuntu 18.04+
+        _get_packages = CommandNotFound.CommandNotFound().get_packages
+    else:
+        # For older versions
+        _get_packages = CommandNotFound().getPackages
+except ImportError:
+    enabled_by_default = False
+
+
+def _get_executable(command):
+    if command.script_parts[0] == 'sudo':
+        return command.script_parts[1]
+    else:
+        return command.script_parts[0]
+
+
+@memoize
+def get_package(executable):
+    try:
+        packages = _get_packages(executable)
+        return packages[0][0]
+    except IndexError:
+        # IndexError is thrown when no matching package is found
+        return None
+
+
+def match(command):
+    if 'not found' in command.output or 'not installed' in command.output:
+        executable = _get_executable(command)
+        return not which(executable) and get_package(executable)
+    else:
+        return False
+
+
+def get_new_command(command):
+    executable = _get_executable(command)
+    name = get_package(executable)
+    formatme = shell.and_('sudo apt-get install {}', '{}')
+    return formatme.format(name, command.script)

thefuck/rules/apt_get_search.py

@@ -0,0 +1,14 @@
+import re
+from thefuck.specific.apt import apt_available
+from thefuck.utils import for_app
+
+enabled_by_default = apt_available
+
+
+@for_app('apt-get')
+def match(command):
+    return command.script.startswith('apt-get search')
+
+
+def get_new_command(command):
+    return re.sub(r'^apt-get', 'apt-cache', command.script)