pyscript-programming-language 1.13.3__py3-none-any.whl → 1.14.0__py3-none-any.whl

pyscript/__init__.py

@@ -9,10 +9,10 @@ if __import__('sys').version_info < (3, 10):
 from . import core
 
 from .core.constants import (
-    DEFAULT, NO_COLOR, DEBUG, SILENT, RETURN_RESULT, DONT_SHOW_BANNER_ON_SHELL, CLASSIC_LINE_SHELL, NO_COLOR_PROMPT,
-    NOTEBOOK, LEXER_HIGHLIGHT, DICT_TO_JSDICT
+    DEFAULT, NO_COLOR, NO_WARNING, SILENT, DEBUG, RETURN_RESULT, DONT_SHOW_BANNER_ON_SHELL, CLASSIC_LINE_SHELL,
+    NO_COLOR_PROMPT, NOTEBOOK, LEXER_HIGHLIGHT, DICT_TO_JSDICT
 )
-from .core.cache import undefined
+from .core.cache import pys_sys, undefined
 from .core.highlight import (
     HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptStyle, PygmentsPyScriptLexer,
     PygmentsPyScriptShellLexer
@@ -24,8 +24,9 @@ __all__ = (
     'core',
     'DEFAULT',
     'NO_COLOR',
-    'DEBUG',
+    'NO_WARNING',
     'SILENT',
+    'DEBUG',
     'RETURN_RESULT',
     'DONT_SHOW_BANNER_ON_SHELL',
     'CLASSIC_LINE_SHELL',
@@ -37,6 +38,7 @@ __all__ = (
     'HLFMT_ANSI',
     'HLFMT_BBCODE',
     'undefined',
+    'pys_sys',
     'version',
     'version_info',
     'pys_highlight',

pyscript/__init__.pyi

@@ -22,8 +22,9 @@ from .core.highlight import (
 
 DEFAULT: int
 NO_COLOR: int
-DEBUG: int
+NO_WARNING: int
 SILENT: int
+DEBUG: int
 RETURN_RESULT: int
 DONT_SHOW_BANNER_ON_SHELL: int
 CLASSIC_LINE_SHELL: int
@@ -36,6 +37,7 @@ HLFMT_HTML: PysHighlightFormatter
 HLFMT_ANSI: PysHighlightFormatter
 HLFMT_BBCODE: PysHighlightFormatter
 
+pys_sys: ModuleType
 undefined: PysUndefined
 version: str
 version_info: PysVersionInfo

pyscript/__main__.py

@@ -1,11 +1,10 @@
 from .core.buffer import PysFileBuffer
 from .core.cache import pys_sys, undefined
 from .core.constants import (
-    ENV_PYSCRIPT_NO_COLOR_PROMPT, ENV_PYSCRIPT_CLASSIC_LINE_SHELL, DEFAULT, DEBUG, NO_COLOR, DONT_SHOW_BANNER_ON_SHELL,
-    CLASSIC_LINE_SHELL, NO_COLOR_PROMPT, NOTEBOOK
+    ENV_PYSCRIPT_NO_COLOR_PROMPT, ENV_PYSCRIPT_CLASSIC_LINE_SHELL, DEFAULT, NO_COLOR, NO_WARNING, DEBUG,
+    DONT_SHOW_BANNER_ON_SHELL, CLASSIC_LINE_SHELL, NO_COLOR_PROMPT, NOTEBOOK
 )
-from .core.editor.gui import PysGUIEditor, GUI_SUPPORT
-from .core.editor.terminal import PysTerminalEditor, TERMINAL_SUPPORT
+from .core import editor
 from .core.highlight import (
     PYGMENTS, HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptStyle, PygmentsPyScriptLexer
 )
@@ -33,24 +32,29 @@ if PYGMENTS:
     }
 
 from argparse import OPTIONAL, REMAINDER, ArgumentParser
+from re import compile as compile_regex
 
 import sys
 
+if sys.version_info >= (3, 13):
+    try:
+        from _colorize import can_colorize
+        COLORIZE = can_colorize()
+    except:
+        # respect for NO_COLOR, see more here: https://no-color.org
+        COLORIZE = not is_environ('NO_COLOR')
+else:
+    COLORIZE = True
+
 FORMATER_HIGHLIGHT_MAP = {
     'html': HLFMT_HTML,
     'ansi': HLFMT_ANSI,
     'bbcode': HLFMT_BBCODE
 }
 
-EDITOR_MAP = {
-    name: cls
-    for support, name, cls in [
-        (GUI_SUPPORT,      'gui',      PysGUIEditor),
-        (TERMINAL_SUPPORT, 'terminal', PysTerminalEditor)
-    ] if support
-}
-
-arguments_requiring_value = {'-l', '--highlight', '-r', '--py-recursion'}
+editors = tuple(editor for editor in editor.__all__ if editor != 'bases')
+arguments_requiring_argv = {'-c', '--command', '-m', '--module'}
+arguments_requiring_value = {'-e', '--editor', '-l', '--highlight', '-r', '--py-recursion'}
 
 parser = ArgumentParser(
     prog=f'{base(sys.executable)} -m pyscript',
@@ -77,14 +81,12 @@ parser.add_argument(
     help="set a debug flag, this will ignore assert statement. Check the flag is active with the __debug__ keyword"
 )
 
-if EDITOR_MAP:
-    parser.add_argument(
-        '-e', '--editor',
-        choices=tuple(EDITOR_MAP.keys()),
-        default=None,
-        help="open the editor panel from a 'file'",
-    )
-    arguments_requiring_value.update({'-e', '--editor'})
+parser.add_argument(
+    '-e', '--editor',
+    choices=editors,
+    default=None,
+    help="open the editor panel from a 'file'",
+)
 
 parser.add_argument(
     '-i', '--inspect',
@@ -100,7 +102,7 @@ parser.add_argument(
 
 parser.add_argument(
     '-l', '--highlight',
-    choices=tuple(FORMATER_HIGHLIGHT_MAP.keys()) + tuple(FORMATER_PYGMENTS_MAP.keys() if PYGMENTS else ()),
+    choices=tuple(FORMATER_HIGHLIGHT_MAP.keys()) + (tuple(FORMATER_PYGMENTS_MAP.keys()) if PYGMENTS else ()),
     default=None,
     help="generate highlight code from a 'file'"
 )
@@ -139,6 +141,12 @@ parser.add_argument(
     help="configure terminal encoding to UTF-8 and enable ANSI escape code processing on Windows"
 )
 
+parser.add_argument(
+    '-w', '--no-warning',
+    action='store_true',
+    help="disabled warning (especially syntax warnings)"
+)
+
 parser.add_argument(
     '-q',
     action='store_true',
@@ -179,23 +187,27 @@ argv = sys.argv[1:]
 argc = len(argv)
 index = 0
 arg_index = -1
+parser_color = COLORIZE
 
 while index < argc:
     arg = argv[index]
-    if not arg.startswith('-') or arg == '--':
-        break
 
-    if arg in ('-c', '--command'):
-        arg_index = index + 2
+    if not arg.startswith('-') or arg == '--':
         break
-    elif arg in ('-m', '--module'):
+    elif arg in arguments_requiring_argv:
         arg_index = index + 2
         break
+    elif arg in ('-n', '--no-color'):
+        parser_color = False
 
     index += 1
     if arg in arguments_requiring_value:
         index += 1
 
+if sys.version_info >= (3, 14):
+    parser.color = parser_color
+    parser.suggest_on_error = True
+
 args = parser.parse_args(argv if arg_index == -1 else argv[:arg_index])
 arg  = args.arg               if arg_index == -1 else argv[arg_index:]
 
@@ -220,7 +232,7 @@ if args.terminal:
             pass
 
 if args.file is None:
-    if EDITOR_MAP and args.editor:
+    if args.editor:
         argument_error('-e/--editor', "argument 'file' is required")
     elif args.highlight:
         argument_error('-l/--highlight', "argument 'file' is required")
@@ -231,66 +243,97 @@ if args.py_recursion is not None:
     except BaseException as e:
         argument_error('-r/--py-recursion', e)
 
+if args.P:
+    for cwd in {'', '.', getcwd()}:
+        remove_python_path(cwd)
+
 code = 0
 flags = DEFAULT
 
 for condition, flag in [
     (args.notebook           or USE_NOTEBOOK,                                NOTEBOOK),
     (args.classic_line_shell or is_environ(ENV_PYSCRIPT_CLASSIC_LINE_SHELL), CLASSIC_LINE_SHELL),
-    (args.no_color           or is_environ('NO_COLOR'),                      NO_COLOR),
+    (args.no_color           or not COLORIZE,                                NO_COLOR),
     (args.no_color_prompt    or is_environ(ENV_PYSCRIPT_NO_COLOR_PROMPT),    NO_COLOR_PROMPT),
     (args.debug,                                                             DEBUG),
+    (args.no_warning,                                                        NO_WARNING),
     (args.q,                                                                 DONT_SHOW_BANNER_ON_SHELL)
 ]:
     if condition:
         flags |= flag
 
-if args.P:
-    for cwd in {'', '.', getcwd()}:
-        remove_python_path(cwd)
-
 pys_sys.argv = argv = ['', *arg]
 
 def clean_up() -> None:
     g = globals()
 
     for name in {
-        'ArgumentParser', 'BBCodeFormatter', 'CLASSIC_LINE_SHELL', 'DEBUG', 'DEFAULT', 'EDITOR_MAP',
-        'ENV_PYSCRIPT_CLASSIC_LINE_SHELL', 'ENV_PYSCRIPT_NO_COLOR_PROMPT', 'FORMATER_HIGHLIGHT_MAP',
-        'FORMATER_PYGMENTS_MAP', 'GUI_SUPPORT', 'HLFMT_ANSI', 'HLFMT_BBCODE', 'HLFMT_HTML', 'HtmlFormatter',
-        'LatexFormatter', 'NOTEBOOK', 'NO_COLOR', 'NO_COLOR_PROMPT', 'OPTIONAL', 'PYGMENTS', 'PygmentsPyScriptLexer',
-        'PygmentsPyScriptStyle', 'PysFileBuffer', 'PysGUIEditor', 'PysTerminalEditor', 'REMAINDER', 'TERMINAL_SUPPORT',
-        'Terminal256Formatter', 'TerminalFormatter', 'TerminalTrueColorFormatter', 'USE_NOTEBOOK', '__version__',
-        '_namespace_to_symbol_table', 'arg', 'arg_index', 'argc', 'args', 'argument_error', 'arguments_requiring_value',
-        'argv', 'base', 'clean_up', 'condition', 'ctypes', 'execute', 'fd', 'file', 'find_module_path', 'flag',
-        'getcwd', 'highlight', 'i', 'index', 'is_environ', 'kernel32', 'load_file', 'module_path', 'parser',
-        'pys_highlight', 'pys_sys', 'remove_python_path'
+        'ArgumentParser', 'BBCodeFormatter', 'CLASSIC_LINE_SHELL', 'DEBUG', 'DEFAULT', 'i', 'index', 'is_environ', 'fd',
+        'kernel32', 'ENV_PYSCRIPT_CLASSIC_LINE_SHELL', 'ENV_PYSCRIPT_NO_COLOR_PROMPT', 'FORMATER_HIGHLIGHT_MAP', 'arg',
+        'FORMATER_PYGMENTS_MAP', 'HLFMT_ANSI', 'HLFMT_BBCODE', 'HLFMT_HTML', 'HtmlFormatter', 'OPTIONAL', 'PYGMENTS',
+        'LatexFormatter', 'NOTEBOOK', 'NO_COLOR', 'NO_WARNING', 'NO_COLOR_PROMPT', 'PygmentsPyScriptLexer', 'args',
+        'PygmentsPyScriptStyle', 'PysFileBuffer', 'REMAINDER', 'Terminal256Formatter', 'TerminalFormatter', 'flag',
+        'TerminalTrueColorFormatter', 'USE_NOTEBOOK', '__version__', '_namespace_to_symbol_table', 'arg_index', 'argc', 
+        'argument_error', 'arguments_requiring_value', 'argv', 'base', 'clean_up', 'condition', 'ctypes', 'execute',
+        'file', 'find_module_path', 'getcwd', 'highlight', 'load_editor_module', 'load_file', 'module_path', 'parser',
+        'pys_highlight', 'pys_sys', 'remove_python_path', 'editors', 'editor', 'compile_regex', 'can_colorize',
+        'arguments_requiring_argv', 'COLORIZE', 'parser_color'
     }:
         try:
             del g[name]
         except:
             continue
 
+def load_editor_module(name: str) -> tuple[type | None, bool]:
+    if name not in editors:
+        return None, False
+
+    module = getattr(editor, name, None)
+    if module is None:
+        return None, False
+
+    class_name = compile_regex(r'Pys[A-Za-z0-9_]+Editor').fullmatch
+    support_name = compile_regex(r'[A-Z0-9_]+_SUPPORT').fullmatch
+
+    cls = None
+    support = None
+    for name in dir(module):
+        if not (cls is None or support is None):
+            break
+        elif class_name(name) and cls is None:
+            cls = getattr(module, name)
+        elif support_name(name) and support is None:
+            support = getattr(module, name)
+    else:
+        return None, False
+
+    return cls, support
+
 def load_file(path) -> PysFileBuffer:
     normalized = normpath(path)
+
+    def open_error(message: str) -> None:
+        argument_error('file', f"can't open file \"{normalized}\": {message}")
+
     try:
-        with open(normalized, 'r', encoding='utf-8') as file:
+        with open(normalized, 'r', encoding=pys_sys.encoding) as file:
             return PysFileBuffer(file, normalized)
     except FileNotFoundError:
-        if not (EDITOR_MAP and args.editor):
-            argument_error('file', f"can't open file \"{normalized}\": No such file or directory")
+        if not args.editor:
+            open_error("No such file or directory")
     except PermissionError:
-        argument_error('file', f"can't open file \"{normalized}\": Permission denied")
+        open_error("Permission denied")
     except IsADirectoryError:
-        argument_error('file', f"can't open file \"{normalized}\": Path is not a file")
+        open_error("Path is not a file")
     except NotADirectoryError:
-        argument_error('file', f"can't open file \"{normalized}\": Attempting to access directory from file")
+        open_error("Attempting to access directory from file")
     except (OSError, IOError):
-        argument_error('file', f"can't open file \"{normalized}\": Attempting to access a system directory or file")
+        open_error("Attempting to access a system directory or file")
     except UnicodeDecodeError:
-        argument_error('file', f"can't read file \"{normalized}\": Bad file")
+        open_error("Bad file")
     except BaseException as e:
         argument_error('file', f"file \"{normalized}\": Unexpected error: {e}")
+
     return PysFileBuffer('', path)
 
 def execute(file: PysFileBuffer) -> None:
@@ -327,9 +370,12 @@ if args.file is not None:
     argv[0] = args.file
     file = load_file(args.file)
 
-    if EDITOR_MAP and args.editor:
+    if args.editor:
+        cls, supported = load_editor_module(args.editor)
+        if not supported:
+            argument_error('-e/--editor', f"'{args.editor}' mode not supported")
         try:
-            EDITOR_MAP[args.editor](file=file, colored=not (flags & NO_COLOR)).run()
+            cls(file, colored=not (flags & NO_COLOR)).run()
         except BaseException as e:
             argument_error('-e/--editor', e)
 

pyscript/core/cache.py

@@ -31,6 +31,7 @@ pys_sys.modules = {}
 pys_sys.interns = {}
 pys_sys.singletons = {}
 pys_sys.argv = ['']
+pys_sys.encoding = 'utf-8'
 pys_sys.flags = DEFAULT
 pys_sys.displayhook = print_display
 pys_sys.excepthook = print_traceback

pyscript/core/constants.py

@@ -10,7 +10,7 @@ GLOBAL_HISTORY_PATH = os.path.join(os.path.expanduser('~'), '.pyscript_history')
 CONFIGURATIONS_PATH = os.path.join(OTHER_PATH, 'configurations.json')
 
 ENV_PYSCRIPT_NO_EXCEPTHOOK = 'PYSCRIPT_NO_EXCEPTHOOK'
-ENV_PYSCRIPT_NO_GIL = 'PYSCRIPT_NO_GIL'
+ENV_PYSCRIPT_WITH_GIL = 'PYSCRIPT_WITH_GIL'
 ENV_PYSCRIPT_NO_READLINE = 'PYSCRIPT_NO_READLINE'
 ENV_PYSCRIPT_NO_TYPECHECK = 'PYSCRIPT_NO_TYPECHECK'
 ENV_PYSCRIPT_NO_COLOR_PROMPT = 'PYSCRIPT_NO_COLOR_PROMPT'
@@ -34,12 +34,13 @@ CONSTANT_KEYWORDS = (
 
 DEFAULT = 0
 NO_COLOR = 1 << 0
-DEBUG = 1 << 1
-SILENT = 1 << 2
-RETURN_RESULT = 1 << 3
-DONT_SHOW_BANNER_ON_SHELL = 1 << 4
-CLASSIC_LINE_SHELL = 1 << 5
-NO_COLOR_PROMPT = 1 << 6
+NO_WARNING = 1 << 1
+SILENT = 1 << 2 | NO_WARNING
+DEBUG = 1 << 3
+RETURN_RESULT = 1 << 4
+DONT_SHOW_BANNER_ON_SHELL = 1 << 5
+CLASSIC_LINE_SHELL = 1 << 6
+NO_COLOR_PROMPT = 1 << 7
 NOTEBOOK = CLASSIC_LINE_SHELL | NO_COLOR_PROMPT
 
 LEXER_HIGHLIGHT = 1 << 0

pyscript/core/context.py

@@ -3,12 +3,9 @@ from .buffer import PysFileBuffer
 from .constants import DEFAULT
 from .position import PysPosition
 from .symtab import PysSymbolTable, PysClassSymbolTable
-from .utils.decorators import immutable
-from .utils.generic import setimuattr
 
 from typing import Optional
 
-@immutable
 class PysContext(Pys):
 
     __slots__ = ('file', 'name', 'qualname', 'flags', 'symbol_table', 'parent', 'parent_entry_position')
@@ -28,13 +25,13 @@ class PysContext(Pys):
         if flags is None and parent:
             flags = parent.flags
 
-        setimuattr(self, 'file', file)
-        setimuattr(self, 'name', name)
-        setimuattr(self, 'qualname', qualname)
-        setimuattr(self, 'flags', DEFAULT if flags is None else flags)
-        setimuattr(self, 'symbol_table', symbol_table)
-        setimuattr(self, 'parent', parent)
-        setimuattr(self, 'parent_entry_position', parent_entry_position)
+        self.file = file
+        self.name = name
+        self.qualname = qualname
+        self.flags = DEFAULT if flags is None else flags
+        self.symbol_table = symbol_table
+        self.parent = parent
+        self.parent_entry_position = parent_entry_position
 
 class PysClassContext(PysContext):
 

pyscript/core/editor/__init__.py

@@ -1,15 +1,31 @@
 """
 All Editor Application Implementations for PyScript.
+
+Not all editors are loaded (lazy import).
 """
 
-from . import (
-    bases,
-    gui,
-    terminal
-)
-
-__all__ = (
-    'bases',
-    'gui',
-    'terminal'
-)
+from ..utils.path import normpath
+
+from importlib import import_module as _import
+from os.path import dirname
+from pkgutil import iter_modules
+
+__all__ = tuple(frozenset(
+    name for _, name, _ in
+    iter_modules((dirname(normpath(__file__)),))
+))
+
+def __getattr__(name: str):
+    g = globals()
+    if name in g:
+        return g[name]
+    elif name in __all__:
+        module = _import(f'{__name__}.{name}')
+        g[name] = module
+        return module
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+def __dir__() -> list[str]:
+    return sorted(tuple(globals().keys()) + __all__)
+
+del normpath, iter_modules, dirname

pyscript/core/editor/bases.py

@@ -1,64 +1,64 @@
 from ..bases import Pys
 from ..buffer import PysFileBuffer
+from ..cache import pys_sys
 from ..constants import CONFIGURATIONS_PATH
 from ..utils.decorators import typecheck, inheritable
-from ..utils.generic import setimuattr
+from ..utils.generic import delimuattr
 from ..utils.string import normstr
 
 from json import dump, load
+from os.path import basename
 from typing import Any
 
-import os
-
 class PysEditor(Pys):
 
     @typecheck
     def __init__(self, file: PysFileBuffer, colored: bool = True) -> None:
         self.file = file
         self.colored = bool(colored)
-        self.basename = os.path.basename(self.file.name)
+        self.basename = basename(self.file.name)
         self.used = False
         self.modified = False
 
+        self.load_configuration()
+
     def __init_subclass__(cls, **kwargs) -> None:
         super().__init_subclass__(**kwargs)
         inheritable(cls)
 
     def load_configuration(self) -> None:
         try:
-            with open(CONFIGURATIONS_PATH, 'r', encoding='utf-8') as file:
+            with open(CONFIGURATIONS_PATH, 'r', encoding=pys_sys.encoding) as file:
                 result = load(file)
-                if not isinstance(result, dict):
+            if not isinstance(result, dict):
+                raise ValueError
+            for key in result:
+                if not isinstance(key, str):
                     raise ValueError
-                for key in result:
-                    if not isinstance(key, str):
-                        raise ValueError
-                self.configurations = result
+            self.configurations = result
         except:
             self.configurations = {}
 
     def get_configuration(self, configuration: str, default: Any) -> Any:
-        if configuration in self.configurations:
-            return self.configurations[configuration]
-        self.configurations[configuration] = default
-        return default
+        return self.configurations.setdefault(configuration, default)
 
     def set_configuration(self, configuration: str, value: Any) -> None:
         self.configurations[configuration] = value
 
     def save_configuration(self) -> None:
         try:
-            with open(CONFIGURATIONS_PATH, 'w', encoding='utf-8') as file:
+            with open(CONFIGURATIONS_PATH, 'w', encoding=pys_sys.encoding) as file:
                 dump(self.configurations, file, separators=(',', ':'))
         except:
             pass
 
     def save(self, text) -> None:
+        if not self.modified:
+            return
+
         try:
-            text = normstr(text)
-            with open(self.file.name, 'w', encoding='utf-8') as file:
-                file.write(text)
-                setimuattr(self.file, 'text', text)
+            with open(self.file.name, 'w', encoding=pys_sys.encoding) as file:
+                file.write(normstr(text))
         except:
             pass
         else:
@@ -67,4 +67,5 @@ class PysEditor(Pys):
     def run(self) -> None:
         if self.used:
             raise RuntimeError("one application object can only be used once")
+        delimuattr(self.file, 'text')
         self.used = True

pyscript/core/editor/gui.py

@@ -1,7 +1,7 @@
 from .bases import PysEditor
 from ..buffer import PysFileBuffer
 from ..constants import ICON_PATH
-from ..highlight import PygmentsPyScriptStyle, PygmentsPyScriptLexer
+from ..highlight import PYGMENTS, PygmentsPyScriptStyle, PygmentsPyScriptLexer
 from ..utils.generic import boundary
 from ..version import __version__
 
@@ -15,7 +15,8 @@ try:
             PysEditor.__init__(self, file, colored)
             Tk.__init__(self)
 
-            self.load_configuration()
+            def update_tab_size():
+                self.text.configure(tabs=(self.font.measure('    '),))
 
             def on_save(event=None):
                 text = self.text.get('1.0', 'end')
@@ -26,46 +27,40 @@ try:
             def on_close():
                 if self.modified:
                     answer = messagebox.askyesnocancel('Unsaved changes', 'File has been modified. Save before exit?')
-                    if answer is True:
+                    if answer is None:
+                        return
+                    elif answer:
                         on_save()
-                        self.save_configuration()
-                        self.destroy()
-                    elif answer is False:
-                        self.save_configuration()
-                        self.destroy()
-                else:
-                    self.save_configuration()
-                    self.destroy()
+                self.save_configuration()
+                self.destroy()
 
             def on_configure(event):
                 if event.widget == self:
                     zoom = self.wm_state() == 'zoomed'
                     self.set_configuration('zoom', zoom)
                     if not zoom:
-                        self.set_configuration(
-                            'gui-geometry',
-                            f'{event.width}x{event.height}+{event.x}+{event.y}'
-                        )
+                        self.set_configuration('gui-geometry', f'{event.width}x{event.height}+{event.x}+{event.y}')
 
             def on_modified(event=None):
-                text = self.text
-                if text.edit_modified():
+                if self.text.edit_modified():
                     self.modified = True
                     update()
-                    text.edit_modified(False)
+                    self.text.edit_modified(False)
 
             def on_change_font(value):
                 def wrapper(event=None):
                     font = self.font
                     size = boundary(font.cget('size') + value, 1, 127)
                     font.config(size=size)
+                    update_tab_size()
                     self.set_configuration('gui-size-font', size)
                     return 'break'
                 return wrapper
 
             def on_toggle_wrap(event=None):
-                wrap = self.text.cget('wrap') != 'char'
-                self.text.configure(wrap='char' if wrap else 'none')
+                text = self.text
+                wrap = text.cget('wrap') != 'char'
+                text.configure(wrap='char' if wrap else 'none')
                 self.set_configuration('wrap', wrap)
                 return 'break'
 
@@ -83,8 +78,12 @@ try:
 
             def on_enter(event=None):
                 text = self.text
+                if text.tag_ranges('sel'):
+                    text.delete('sel.first', 'sel.last')
+
                 line = text.get('insert linestart', 'insert lineend')
                 text.insert('insert', '\n' + line[:len(line) - len(line.lstrip())])
+                text.see('insert')
                 return 'break'
 
             self.lexer = PygmentsPyScriptLexer()
@@ -102,6 +101,8 @@ try:
                 yscrollcommand=self.scrollbar.set
             )
 
+            update_tab_size()
+
             self.scrollbar.pack_configure(side='right', fill='y')
             self.scrollbar.configure(command=self.text.yview)
 
@@ -140,10 +141,10 @@ try:
                 )
             )
 
-            self.wm_minsize(300, 250)
+            self.wm_minsize(250, 200)
             self.wm_protocol('WM_DELETE_WINDOW', on_close)
 
-            if colored:
+            if PYGMENTS and colored:
                 tag_configure = self.text.tag_configure
                 for token, style in PygmentsPyScriptStyle.list_styles():
                     color = style['color']