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

thefuck/argument_parser.py

@@ -0,0 +1,96 @@
+import sys
+from argparse import ArgumentParser, SUPPRESS
+from .const import ARGUMENT_PLACEHOLDER
+from .utils import get_alias
+
+
+class Parser(object):
+    """Argument parser that can handle arguments with our special
+    placeholder.
+
+    """
+
+    def __init__(self):
+        self._parser = ArgumentParser(prog='thefuck', add_help=False)
+        self._add_arguments()
+
+    def _add_arguments(self):
+        """Adds arguments to parser."""
+        self._parser.add_argument(
+            '-v', '--version',
+            action='store_true',
+            help="show program's version number and exit")
+        self._parser.add_argument(
+            '-a', '--alias',
+            nargs='?',
+            const=get_alias(),
+            help='[custom-alias-name] prints alias for current shell')
+        self._parser.add_argument(
+            '-l', '--shell-logger',
+            action='store',
+            help='log shell output to the file')
+        self._parser.add_argument(
+            '--setup',
+            action='store_true',
+            help='interactive setup for AI environment variables')
+        self._parser.add_argument(
+            '--enable-experimental-instant-mode',
+            action='store_true',
+            help='enable experimental instant mode, use on your own risk')
+        self._parser.add_argument(
+            '-h', '--help',
+            action='store_true',
+            help='show this help message and exit')
+        self._add_conflicting_arguments()
+        self._parser.add_argument(
+            '-d', '--debug',
+            action='store_true',
+            help='enable debug output')
+        self._parser.add_argument(
+            '--force-command',
+            action='store',
+            help=SUPPRESS)
+        self._parser.add_argument(
+            'command',
+            nargs='*',
+            help='command that should be fixed')
+
+    def _add_conflicting_arguments(self):
+        """It's too dangerous to use `-y` and `-r` together."""
+        group = self._parser.add_mutually_exclusive_group()
+        group.add_argument(
+            '-y', '--yes', '--yeah', '--hard',
+            action='store_true',
+            help='execute fixed command without confirmation')
+        group.add_argument(
+            '-r', '--repeat',
+            action='store_true',
+            help='repeat on failure')
+
+    def _prepare_arguments(self, argv):
+        """Prepares arguments by:
+
+        - removing placeholder and moving arguments after it to beginning,
+          we need this to distinguish arguments from `command` with ours;
+
+        - adding `--` before `command`, so our parse would ignore arguments
+          of `command`.
+
+        """
+        if ARGUMENT_PLACEHOLDER in argv:
+            index = argv.index(ARGUMENT_PLACEHOLDER)
+            return argv[index + 1:] + ['--'] + argv[:index]
+        elif argv and not argv[0].startswith('-') and argv[0] != '--':
+            return ['--'] + argv
+        else:
+            return argv
+
+    def parse(self, argv):
+        arguments = self._prepare_arguments(argv[1:])
+        return self._parser.parse_args(arguments)
+
+    def print_usage(self):
+        self._parser.print_usage(sys.stderr)
+
+    def print_help(self):
+        self._parser.print_help(sys.stderr)

thefuck/conf.py

@@ -0,0 +1,141 @@
+import os
+import sys
+from warnings import warn
+from six import text_type
+from . import const
+from .system import Path
+
+try:
+    import importlib.util
+
+    def load_source(name, pathname, _file=None):
+        module_spec = importlib.util.spec_from_file_location(name, pathname)
+        module = importlib.util.module_from_spec(module_spec)
+        module_spec.loader.exec_module(module)
+        return module
+except ImportError:
+    from imp import load_source
+
+
+class Settings(dict):
+    def __getattr__(self, item):
+        return self.get(item)
+
+    def __setattr__(self, key, value):
+        self[key] = value
+
+    def init(self, args=None):
+        """Fills `settings` with values from `settings.py` and env."""
+        from .logs import exception
+
+        self._setup_user_dir()
+        self._init_settings_file()
+
+        try:
+            self.update(self._settings_from_file())
+        except Exception:
+            exception("Can't load settings from file", sys.exc_info())
+
+        try:
+            self.update(self._settings_from_env())
+        except Exception:
+            exception("Can't load settings from env", sys.exc_info())
+
+        self.update(self._settings_from_args(args))
+
+    def _init_settings_file(self):
+        settings_path = self.user_dir.joinpath('settings.py')
+        if not settings_path.is_file():
+            with settings_path.open(mode='w') as settings_file:
+                settings_file.write(const.SETTINGS_HEADER)
+                for setting in const.DEFAULT_SETTINGS.items():
+                    settings_file.write(u'# {} = {}\n'.format(*setting))
+
+    def _get_user_dir_path(self):
+        """Returns Path object representing the user config resource"""
+        xdg_config_home = os.environ.get('XDG_CONFIG_HOME', '~/.config')
+        user_dir = Path(xdg_config_home, 'thefuck').expanduser()
+        legacy_user_dir = Path('~', '.thefuck').expanduser()
+
+        # For backward compatibility use legacy '~/.thefuck' if it exists:
+        if legacy_user_dir.is_dir():
+            warn(u'Config path {} is deprecated. Please move to {}'.format(
+                legacy_user_dir, user_dir))
+            return legacy_user_dir
+        else:
+            return user_dir
+
+    def _setup_user_dir(self):
+        """Returns user config dir, create it when it doesn't exist."""
+        user_dir = self._get_user_dir_path()
+
+        rules_dir = user_dir.joinpath('rules')
+        if not rules_dir.is_dir():
+            rules_dir.mkdir(parents=True)
+        self.user_dir = user_dir
+
+    def _settings_from_file(self):
+        """Loads settings from file."""
+        settings = load_source(
+            'settings', text_type(self.user_dir.joinpath('settings.py')))
+        return {key: getattr(settings, key)
+                for key in const.DEFAULT_SETTINGS.keys()
+                if hasattr(settings, key)}
+
+    def _rules_from_env(self, val):
+        """Transforms rules list from env-string to python."""
+        val = val.split(':')
+        if 'DEFAULT_RULES' in val:
+            val = const.DEFAULT_RULES + [rule for rule in val if rule != 'DEFAULT_RULES']
+        return val
+
+    def _priority_from_env(self, val):
+        """Gets priority pairs from env."""
+        for part in val.split(':'):
+            try:
+                rule, priority = part.split('=')
+                yield rule, int(priority)
+            except ValueError:
+                continue
+
+    def _val_from_env(self, env, attr):
+        """Transforms env-strings to python."""
+        val = os.environ[env]
+        if attr in ('rules', 'exclude_rules'):
+            return self._rules_from_env(val)
+        elif attr == 'priority':
+            return dict(self._priority_from_env(val))
+        elif attr in ('wait_command', 'history_limit', 'wait_slow_command',
+                      'num_close_matches', 'ai_timeout'):
+            return int(val)
+        elif attr in ('require_confirmation', 'no_colors', 'debug',
+                      'alter_history', 'instant_mode', 'ai_enabled',
+                      'ai_stream', 'ai_stream_output'):
+            return val.lower() == 'true'
+        elif attr in ('slow_commands', 'excluded_search_path_prefixes'):
+            return val.split(':')
+        else:
+            return val
+
+    def _settings_from_env(self):
+        """Loads settings from env."""
+        return {attr: self._val_from_env(env, attr)
+                for env, attr in const.ENV_TO_ATTR.items()
+                if env in os.environ}
+
+    def _settings_from_args(self, args):
+        """Loads settings from args."""
+        if not args:
+            return {}
+
+        from_args = {}
+        if args.yes:
+            from_args['require_confirmation'] = not args.yes
+        if args.debug:
+            from_args['debug'] = args.debug
+        if args.repeat:
+            from_args['repeat'] = args.repeat
+        return from_args
+
+
+settings = Settings(const.DEFAULT_SETTINGS)

thefuck/const.py

@@ -0,0 +1,111 @@
+# -*- encoding: utf-8 -*-
+
+
+class _GenConst(object):
+    def __init__(self, name):
+        self._name = name
+
+    def __repr__(self):
+        return u'<const: {}>'.format(self._name)
+
+
+KEY_UP = _GenConst('↑')
+KEY_DOWN = _GenConst('↓')
+KEY_CTRL_C = _GenConst('Ctrl+C')
+KEY_CTRL_N = _GenConst('Ctrl+N')
+KEY_CTRL_P = _GenConst('Ctrl+P')
+KEY_TAB = _GenConst('Tab')
+
+KEY_MAPPING = {'\x0e': KEY_CTRL_N,
+               '\x03': KEY_CTRL_C,
+               '\x10': KEY_CTRL_P,
+               '\t': KEY_TAB}
+
+ACTION_SELECT = _GenConst('select')
+ACTION_ABORT = _GenConst('abort')
+ACTION_PREVIOUS = _GenConst('previous')
+ACTION_NEXT = _GenConst('next')
+
+ALL_ENABLED = _GenConst('All rules enabled')
+DEFAULT_RULES = [ALL_ENABLED]
+DEFAULT_PRIORITY = 1000
+
+DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
+                    'exclude_rules': [],
+                    'wait_command': 3,
+                    'require_confirmation': True,
+                    'no_colors': False,
+                    'debug': False,
+                    'priority': {},
+                    'history_limit': None,
+                    'alter_history': True,
+                    'wait_slow_command': 15,
+                    'slow_commands': ['lein', 'react-native', 'gradle',
+                                      './gradlew', 'vagrant'],
+                    'repeat': False,
+                    'instant_mode': False,
+                    'num_close_matches': 3,
+                    'env': {'LC_ALL': 'C', 'LANG': 'C', 'GIT_TRACE': '1'},
+                    'excluded_search_path_prefixes': [],
+                    'ai_enabled': True,
+                    'ai_url': 'http://127.0.0.1:8000/v1/chat/completions',
+                    'ai_token': 'devtoken',
+                    'ai_model': 'gpt-5.2',
+                    'ai_timeout': 5,
+                    'ai_reasoning_effort': 'low',
+                    'ai_stream': True,
+                    'ai_mode': 'prefer',
+                    'ai_stream_output': True}
+
+ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
+               'THEFUCK_EXCLUDE_RULES': 'exclude_rules',
+               'THEFUCK_WAIT_COMMAND': 'wait_command',
+               'THEFUCK_REQUIRE_CONFIRMATION': 'require_confirmation',
+               'THEFUCK_NO_COLORS': 'no_colors',
+               'THEFUCK_DEBUG': 'debug',
+               'THEFUCK_PRIORITY': 'priority',
+               'THEFUCK_HISTORY_LIMIT': 'history_limit',
+               'THEFUCK_ALTER_HISTORY': 'alter_history',
+               'THEFUCK_WAIT_SLOW_COMMAND': 'wait_slow_command',
+               'THEFUCK_SLOW_COMMANDS': 'slow_commands',
+               'THEFUCK_REPEAT': 'repeat',
+               'THEFUCK_INSTANT_MODE': 'instant_mode',
+               'THEFUCK_NUM_CLOSE_MATCHES': 'num_close_matches',
+               'THEFUCK_EXCLUDED_SEARCH_PATH_PREFIXES': 'excluded_search_path_prefixes',
+               'THEFUCK_AI_ENABLED': 'ai_enabled',
+               'THEFUCK_AI_URL': 'ai_url',
+               'THEFUCK_AI_TOKEN': 'ai_token',
+               'THEFUCK_AI_MODEL': 'ai_model',
+               'THEFUCK_AI_TIMEOUT': 'ai_timeout',
+               'THEFUCK_AI_REASONING_EFFORT': 'ai_reasoning_effort',
+               'THEFUCK_AI_STREAM': 'ai_stream',
+               'THEFUCK_AI_MODE': 'ai_mode',
+               'THEFUCK_AI_STREAM_OUTPUT': 'ai_stream_output'}
+
+SETTINGS_HEADER = u"""# The Fuck settings file
+#
+# The rules are defined as in the example bellow:
+#
+# rules = ['cd_parent', 'git_push', 'python_command', 'sudo']
+#
+# The default values are as follows. Uncomment and change to fit your needs.
+# See https://github.com/nvbn/thefuck#settings for more information.
+#
+
+"""
+
+ARGUMENT_PLACEHOLDER = 'THEFUCK_ARGUMENT_PLACEHOLDER'
+
+CONFIGURATION_TIMEOUT = 60
+
+USER_COMMAND_MARK = u'\u200B' * 10
+
+LOG_SIZE_IN_BYTES = 1024 * 1024
+
+LOG_SIZE_TO_CLEAN = 10 * 1024
+
+DIFF_WITH_ALIAS = 0.5
+
+SHELL_LOGGER_SOCKET_ENV = 'SHELL_LOGGER_SOCKET'
+
+SHELL_LOGGER_LIMIT = 5

thefuck/corrector.py

@@ -0,0 +1,92 @@
+import sys
+from .conf import settings
+from .types import Rule
+from .system import Path
+from . import logs
+
+
+def get_loaded_rules(rules_paths):
+    """Yields all available rules.
+
+    :type rules_paths: [Path]
+    :rtype: Iterable[Rule]
+
+    """
+    for path in rules_paths:
+        if path.name != '__init__.py':
+            rule = Rule.from_path(path)
+            if rule and rule.is_enabled:
+                yield rule
+
+
+def get_rules_import_paths():
+    """Yields all rules import paths.
+
+    :rtype: Iterable[Path]
+
+    """
+    # Bundled rules:
+    yield Path(__file__).parent.joinpath('rules')
+    # Rules defined by user:
+    yield settings.user_dir.joinpath('rules')
+    # Packages with third-party rules:
+    for path in sys.path:
+        for contrib_module in Path(path).glob('thefuck_contrib_*'):
+            contrib_rules = contrib_module.joinpath('rules')
+            if contrib_rules.is_dir():
+                yield contrib_rules
+
+
+def get_rules():
+    """Returns all enabled rules.
+
+    :rtype: [Rule]
+
+    """
+    paths = [rule_path for path in get_rules_import_paths()
+             for rule_path in sorted(path.glob('*.py'))]
+    return sorted(get_loaded_rules(paths),
+                  key=lambda rule: rule.priority)
+
+
+def organize_commands(corrected_commands):
+    """Yields sorted commands without duplicates.
+
+    :type corrected_commands: Iterable[thefuck.types.CorrectedCommand]
+    :rtype: Iterable[thefuck.types.CorrectedCommand]
+
+    """
+    try:
+        first_command = next(corrected_commands)
+        yield first_command
+    except StopIteration:
+        return
+
+    without_duplicates = {
+        command for command in sorted(
+            corrected_commands, key=lambda command: command.priority)
+        if command != first_command}
+
+    sorted_commands = sorted(
+        without_duplicates,
+        key=lambda corrected_command: corrected_command.priority)
+
+    logs.debug(u'Corrected commands: {}'.format(
+        ', '.join(u'{}'.format(cmd) for cmd in [first_command] + sorted_commands)))
+
+    for command in sorted_commands:
+        yield command
+
+
+def get_corrected_commands(command):
+    """Returns generator with sorted and unique corrected commands.
+
+    :type command: thefuck.types.Command
+    :rtype: Iterable[thefuck.types.CorrectedCommand]
+
+    """
+    corrected_commands = (
+        corrected for rule in get_rules()
+        if rule.is_match(command)
+        for corrected in rule.get_corrected_commands(command))
+    return organize_commands(corrected_commands)

thefuck/entrypoints/alias.py

@@ -0,0 +1,28 @@
+import six
+from ..conf import settings
+from ..logs import warn
+from ..shells import shell
+from ..utils import which
+
+
+def _get_alias(known_args):
+    if six.PY2:
+        warn("The Fuck will drop Python 2 support soon, more details "
+             "https://github.com/nvbn/thefuck/issues/685")
+
+    alias = shell.app_alias(known_args.alias)
+
+    if known_args.enable_experimental_instant_mode:
+        if six.PY2:
+            warn("Instant mode requires Python 3")
+        elif not which('script'):
+            warn("Instant mode requires `script` app")
+        else:
+            return shell.instant_mode_alias(known_args.alias)
+
+    return alias
+
+
+def print_alias(known_args):
+    settings.init(known_args)
+    print(_get_alias(known_args))

thefuck/entrypoints/fix_command.py

@@ -0,0 +1,105 @@
+from pprint import pformat
+import os
+import sys
+from difflib import SequenceMatcher
+from itertools import chain
+from .. import logs, types, const
+from ..conf import settings
+from ..corrector import get_corrected_commands
+from ..exceptions import EmptyCommand
+from ..ui import select_command
+from ..utils import format_raw_script, get_alias, get_all_executables
+from ..ai import (build_corrected_commands, emit_ai_commands, emit_ai_result,
+                  fallback_corrected_commands, get_ai_suggestion, is_enabled)
+
+
+def _get_raw_command(known_args):
+    if known_args.force_command:
+        return [known_args.force_command]
+    tf_command = os.environ.get('TF_COMMAND')
+    if tf_command:
+        return [tf_command]
+    elif not os.environ.get('TF_HISTORY'):
+        return known_args.command
+    else:
+        history = os.environ['TF_HISTORY'].split('\n')[::-1]
+        alias = get_alias()
+        executables = get_all_executables()
+        for command in history:
+            diff = SequenceMatcher(a=alias, b=command).ratio()
+            if diff < const.DIFF_WITH_ALIAS or command in executables:
+                return [command]
+    return []
+
+
+def _get_ai_prompt(known_args):
+    env_prompt = os.environ.get('TF_PROMPT', '').strip()
+    if env_prompt:
+        return env_prompt
+    if not os.environ.get('TF_HISTORY'):
+        return
+    prompt = format_raw_script(known_args.command)
+    return prompt or None
+
+
+def _emit_ai_if_needed(ai_result):
+    if not ai_result:
+        return ai_result
+    if ai_result.streamed:
+        if ai_result.commands:
+            emit_ai_commands(ai_result)
+        return ai_result
+    if ai_result.explanation or ai_result.commands:
+        emit_ai_result(ai_result)
+        return ai_result._replace(streamed=True)
+    return ai_result
+
+
+def fix_command(known_args):
+    """Fixes previous command. Used when `thefuck` called without arguments."""
+    settings.init(known_args)
+    with logs.debug_time('Total'):
+        logs.debug(u'Run with settings: {}'.format(pformat(settings)))
+        raw_command = _get_raw_command(known_args)
+
+        try:
+            command = types.Command.from_raw_script(raw_command)
+        except EmptyCommand:
+            logs.debug('Empty command, nothing to do')
+            return
+
+        corrected_commands = get_corrected_commands(command)
+        ai_prompt = _get_ai_prompt(known_args)
+        if is_enabled():
+            if ai_prompt:
+                ai_result = get_ai_suggestion(
+                    command, prompt=ai_prompt, warn_on_error=True)
+                if ai_result:
+                    ai_result = _emit_ai_if_needed(ai_result)
+                    if ai_result.commands:
+                        corrected_commands = iter(
+                            build_corrected_commands(ai_result))
+                    elif ai_result.explanation:
+                        sys.exit(1)
+                    else:
+                        sys.exit(1)
+            elif settings.ai_mode == 'prefer':
+                ai_result = get_ai_suggestion(command)
+                if ai_result:
+                    ai_result = _emit_ai_if_needed(ai_result)
+                    if ai_result.commands:
+                        ai_commands = build_corrected_commands(ai_result)
+                        corrected_commands = chain(ai_commands,
+                                                   corrected_commands)
+            else:
+                corrected_commands, ai_result = fallback_corrected_commands(
+                    command, corrected_commands)
+                ai_result = _emit_ai_if_needed(ai_result)
+                if ai_result and not ai_result.commands and ai_result.explanation:
+                    sys.exit(1)
+        selected_command = select_command(corrected_commands)
+
+        if selected_command:
+            selected_command.run(command)
+        else:
+            sys.exit(1)

thefuck/entrypoints/main.py

@@ -0,0 +1,50 @@
+# Initialize output before importing any module, that can use colorama.
+from ..system import init_output
+
+init_output()
+
+import os  # noqa: E402
+import sys  # noqa: E402
+from .. import logs  # noqa: E402
+from ..argument_parser import Parser  # noqa: E402
+from ..utils import get_installation_version  # noqa: E402
+from ..shells import shell  # noqa: E402
+from .alias import print_alias  # noqa: E402
+from .fix_command import fix_command  # noqa: E402
+from .setup import setup  # noqa: E402
+
+
+def _is_setup_command(known_args):
+    if getattr(known_args, 'setup', False):
+        return True
+    return bool(known_args.command and known_args.command[0] in (
+        'setup', 'ai-setup'))
+
+
+def main():
+    parser = Parser()
+    known_args = parser.parse(sys.argv)
+
+    if known_args.help:
+        parser.print_help()
+    elif known_args.version:
+        logs.version(get_installation_version(),
+                     sys.version.split()[0], shell.info())
+    # It's important to check if an alias is being requested before checking if
+    # `TF_HISTORY` is in `os.environ`, otherwise it might mess with subshells.
+    # Check https://github.com/nvbn/thefuck/issues/921 for reference
+    elif known_args.alias:
+        print_alias(known_args)
+    elif _is_setup_command(known_args):
+        setup()
+    elif known_args.command or 'TF_HISTORY' in os.environ:
+        fix_command(known_args)
+    elif known_args.shell_logger:
+        try:
+            from .shell_logger import shell_logger  # noqa: E402
+        except ImportError:
+            logs.warn('Shell logger supports only Linux and macOS')
+        else:
+            shell_logger(known_args.shell_logger)
+    else:
+        parser.print_usage()