rp 0.1.1303__tar.gz → 0.1.1305__tar.gz

{rp-0.1.1303 → rp-0.1.1305}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: rp
-Version: 0.1.1303
+Version: 0.1.1305
 Summary: Ryan's Python
 Home-page: https://github.com/RyannDaGreat/Quick-Python
 Author: Ryan Burgert

{rp-0.1.1303 → rp-0.1.1305}/rp/__main__.py

@@ -19,7 +19,11 @@ def arg_eval(code):
 
 def pop_kwargs():
     kwargs = {}
-    while len(sys.argv) > 3 and rp.starts_with_any(sys.argv[-2], "--", "---"):
+    while (
+        len(sys.argv) > 3
+        and rp.starts_with_any(sys.argv[-2], "--", "---")
+        and sys.argv[-2] not in ["--", "---"]
+    ):
         #While we might have a "--kwarg value" at the end
         value = sys.argv.pop()
         name  = sys.argv.pop()
@@ -44,7 +48,13 @@ def pop_args():
     args = []
     while len(sys.argv) > 3:
         value = sys.argv.pop()
-        value = arg_eval(value)
+
+        if sys.argv[-1] == '---':
+            #Treat --- as string literal arg
+            del sys.argv[-1]
+        else:
+            value = arg_eval(value)
+
         args.insert(0, value)
     return args
 
@@ -61,7 +71,9 @@ HELP:
               Format: rp exec <code> --variable1 value1 --variable2 value2
       
     Note: All kwargs whose keys start with -- are evaluated as python code, 
-        and all that start with --- are treated as string literals
+          and all that start with --- are treated as string literals
+          Positional args are treated as string literals if --- precedes them
+          For example, `rp call list 123` is an error, but `rp call list --- 123` --> ['1', '2', '3']
 
     If no command is provided, an interactive Python terminal (rp.pterm) is started.
 """

{rp-0.1.1303 → rp-0.1.1305}/rp/experimental/stdin_python_highlighter.py

@@ -826,11 +826,37 @@ def print_python_line_summary(code,linum):
     print(fansi('     ',None,None,'black')+out+fansi(' '*1000,None,None,'black'))
     return out
 
+def stdin_read_robust(encoding='utf-8', errors='replace'):
+  """
+  Reads from standard input robustly by handling potential UnicodeDecodeErrors.
+
+  This function reads the raw byte stream from stdin and decodes it into a 
+  string using a specified encoding and error-handling strategy.
+
+  Args:
+    encoding (str): The text encoding to use (e.g., 'utf-8', 'latin-1'). 
+                    Defaults to 'utf-8'.
+    errors (str): The strategy for handling decoding errors. Common options are
+                  'replace' (inserts a placeholder ), 'ignore' (discards the
+                  problematic byte), or 'strict' (raises an error). 
+                  Defaults to 'replace'.
+
+  Returns:
+    str: The decoded string from standard input.
+  """
+  # Read the raw, undecoded bytes from the standard input buffer
+  raw_input = sys.stdin.buffer.read()
+  
+  # Decode the bytes into a string using the specified error handling
+  text_input = raw_input.decode(encoding, errors=errors)
+  
+  return text_input
+
 def start(text=None):
 
     # HARDCODED_WIDTH=None
 
-    text=text or sys.stdin.read()
+    text=text or stdin_read_robust()
 
     lines=text.splitlines()
     if len(lines)==1 and '\\n' in lines[0]:

{rp-0.1.1303 → rp-0.1.1305}/rp/prompt_toolkit/history.py

@@ -106,36 +106,72 @@ class FileHistory(History):
 
     def _load(self):
         #took .2 seconds with 18000 items in history; 
-        # from rp import sleep,tic,toc,ptoc,ptoctic,ring_terminal_bell,run_as_new_thread,text_to_speech
         from rp import run_as_new_thread
-        # ring_terminal_bell()
-        # tic()
 
-        lines = []
-
-        def add():
-            if lines:
-                # Join and drop trailing newline.
-                string = ''.join(lines)[:-1]
-
-                self.strings.append(string)
-
-        def add_all_lines():
-            nonlocal lines
-            from time import sleep
-            if os.path.exists(self.filename):
+        def load_history():
+            if not os.path.exists(self.filename):
+                return
+            
+            # Phase 1: Load last _fast_pterm_history_size for immediate access  
+            # (This two-phase system which first loads a few history lines then loads them all was written by Claude in Aug 2025. It resulted in a massive speed boost allowing us to get history with the up arrow key immediately after booting rp. This only became noticeable after other improvements to boot time made RP boot faster than it could read the whole history file.)
+            try:
+                import rp
+                fast_size = rp.r._fast_pterm_history_size
                 with open(self.filename, 'rb') as f:
+                    f.seek(0, 2)  # Go to end
+                    file_size = f.tell()
+                    start_pos = max(0, file_size - fast_size)
+                    f.seek(start_pos)
+                    data = f.read().decode('utf-8', errors='ignore')
+                
+                # Parse the tail data quickly
+                lines = []
+                temp_strings = []
+                
+                for line in data.split('\n'):
+                    if line.startswith('+'):
+                        lines.append(line[1:] + '\n')
+                    else:
+                        if lines:
+                            string = ''.join(lines)[:-1]
+                            temp_strings.append(string)
+                        lines = []
+                if lines:
+                    string = ''.join(lines)[:-1]
+                    temp_strings.append(string)
+                
+                # Set partial results immediately
+                self.strings = temp_strings
+            except Exception:
+                pass
+            
+            # Phase 2: Load complete file (overwrites partial results)
+            try:
+                with open(self.filename, 'rb') as f:
+                    lines = []
+                    complete_strings = []
+                    
                     for line in f:
-                        # print(line)
                         line = line.decode('utf-8')
-
                         if line.startswith('+'):
                             lines.append(line[1:])
                         else:
-                            add()
+                            if lines:
+                                string = ''.join(lines)[:-1]
+                                complete_strings.append(string)
                             lines = []
-                    add()
-            # text_to_speech("a")
+                    if lines:
+                        string = ''.join(lines)[:-1]
+                        complete_strings.append(string)
+                
+                # Replace with complete results
+                self.strings = complete_strings
+                
+                # Notify that full loading is complete
+                import rp
+                rp.r._on_history_load_complete(self)
+            except Exception:
+                pass
         # if os.path.exists(self.filename):
         #     with open(self.filename, 'rb') as f:
         #         for line in f:
@@ -147,10 +183,34 @@ class FileHistory(History):
         #                 add()
         #                 lines = []
         #         add()
-        run_as_new_thread(add_all_lines)#Running this as a new thread will save .2 seconds with my 18000 items in history
-        # ptoctic()
-        # sleep(3)
-        # ring_terminal_bell()
+
+        #FIRST ATTEMPT AT GOING REVERSE ORDER. BUT ITS SLOWER AND LAGS A BIT...ALSO WE GOTTA DO PROCESSING CORRECTLY...
+        # def prepend():
+        #     if lines:
+        #         # Join and drop trailing newline.
+        #         string = '\n'.join(lines)
+        #
+        #         self.strings.insert(0,string) #Meh it's fast enough even though it's technically O(n^2) right?
+        #
+        # def add_all_lines():
+        #     import rp
+        #     nonlocal lines
+        #     if os.path.exists(self.filename):
+        #         # with open(self.filename, 'rb') as f:
+        #         #     for line in f:
+        #             for line in rp.file_line_iterator(self.filename, reverse=True):
+        #                 # print(line)
+        #                 # line = line.decode('utf-8')
+        #
+        #                 if line.startswith('+'):
+        #                     lines.append(line[1:])
+        #                 else:
+        #                     prepend()
+        #                     lines = []
+        #             prepend()
+        #     rp.text_to_speech("b")
+                    
+        run_as_new_thread(load_history)  # Single thread with two-phase loading
 
     def append(self, string):
         self.strings.append(string)

{rp-0.1.1303 → rp-0.1.1305}/rp/prompt_toolkit/layout/lexers.py

@@ -14,22 +14,15 @@ from .utils import split_lines
 import re
 import six
 
-# <CLAUDE CODE START: Adding imports for multi-language highlighting>
-from pygments.lexers import Python3Lexer
-from pygments.lexers import (
-    BashLexer, JavascriptLexer, HtmlLexer, SqlLexer, JsonLexer,
-    CssLexer, XmlLexer, YamlLexer, RubyLexer, PhpLexer, CppLexer,
-    CLexer, RustLexer, GoLexer, CSharpLexer, JavaLexer, MakefileLexer,
-    PerlLexer, TypeScriptLexer, SwiftLexer, KotlinLexer, ScalaLexer,
-    ObjectiveCLexer, DartLexer, MarkdownLexer, DiffLexer
-)
-from pygments.token import Token
-# <CLAUDE CODE END: Adding imports for multi-language highlighting>
+# <CLAUDE CODE START: Lazy imports for multi-language highlighting - imports deferred until needed>
+# Lexer imports moved inside LazyLexer classes to avoid slow startup
+# <CLAUDE CODE END: Lazy imports for multi-language highlighting>
 
 __all__ = (
     'Lexer',
     'SimpleLexer',
     'PygmentsLexer',
+    'LazyPygmentsLexer',
     'SyntaxSync',
     'SyncFromStart',
     'RegexSync',
@@ -190,8 +183,82 @@ def longest_common_prefix(a,b):
 
 
 
+class LazyLexer:
+    """
+    Lazy wrapper for Pygments lexers to avoid slow initialization and imports.
+    This class was Lazy lexers written by Claude, Aug 5 2025. Resulted in massive pterm boot speed boost. Pygments initializations were taking the majority of the time.
+    """
+    def __init__(self, lexer_module_path, lexer_class_name, *args, **kwargs):
+        self.lexer_module_path = lexer_module_path
+        self.lexer_class_name = lexer_class_name
+        self.args = args
+        self.kwargs = kwargs
+        self._lexer = None
+        self._lexer_class = None
+    
+    def _get_lexer_class(self):
+        if self._lexer_class is None:
+            import importlib
+            module = importlib.import_module(self.lexer_module_path)
+            self._lexer_class = getattr(module, self.lexer_class_name)
+        return self._lexer_class
+    
+    def _get_lexer(self):
+        if self._lexer is None:
+            lexer_class = self._get_lexer_class()
+            self._lexer = lexer_class(*self.args, **self.kwargs)
+        return self._lexer
+    
+    def get_tokens_unprocessed(self, text):
+        return self._get_lexer().get_tokens_unprocessed(text)
+    
+    def __getattr__(self, name):
+        return getattr(self._get_lexer(), name)
+
+
+class LazyBashLexer(LazyLexer):
+    """
+    Special lazy wrapper for BashLexer that adds system commands on initialization.
+    This class was Lazy lexers written by Claude, Aug 5 2025. Resulted in massive pterm boot speed boost. Pygments initializations were taking the majority of the time.
+    """
+    _system_commands_added = False  # Class variable to track if we've already modified BashLexer globally
+    
+    def _get_lexer(self):
+        if self._lexer is None:
+            # Add system commands to global BashLexer class if not already done
+            if not LazyBashLexer._system_commands_added:
+                self._add_system_commands_to_pterm_bash_highlighter()
+                LazyBashLexer._system_commands_added = True
+            
+            # Now initialize the lexer (which will inherit the modified tokens)
+            lexer_class = self._get_lexer_class()
+            self._lexer = lexer_class(*self.args, **self.kwargs)
+        return self._lexer
+    
+    def _add_system_commands_to_pterm_bash_highlighter(self):
+        """ 
+        This function lets us syntax-highlight any system commands in the !<shell stuff> in pterm seen upon boot 
+        It can't update them over time right now, it's a one-time thing
+        """ 
+        import pygments.lexers.shell as shell
+        import re
+        import rp
+        Name = shell.Name
+        commands = rp.get_system_commands() + ['!']
+        shell.BashLexer.tokens['basic'] += [(r'(^|!|\b)(' + '|'.join(re.escape(x) for x in commands) + r')(?=[\s)\`]|$)', Name.Function),]
+
+
 class FastPygmentsTokenizer:
-    def __init__(self,pygments_lexer=Python3Lexer()):
+    def __init__(self,pygments_lexer=None):
+        if pygments_lexer is None:
+            # Lazy import of default lexer
+            import six
+            if six.PY2:
+                from pygments.lexers import PythonLexer
+                pygments_lexer = PythonLexer()
+            else:
+                from pygments.lexers import Python3Lexer
+                pygments_lexer = Python3Lexer()
         self.old_text=''
         self.token_cache=[]
         self.pygments_lexer=pygments_lexer
@@ -199,34 +266,34 @@ class FastPygmentsTokenizer:
         # <CLAUDE CODE START: Initialize language lexers for multi-language highlighting>
         # Common lexer options
         lexer_options = {'stripnl': False, 'stripall': False, 'ensurenl': False}
-        
-        # Initialize all lexers with the same options
-        self.bash_lexer = BashLexer(**lexer_options)
-        self.javascript_lexer = JavascriptLexer(**lexer_options)
-        self.html_lexer = HtmlLexer(**lexer_options)
-        self.sql_lexer = SqlLexer(**lexer_options)
-        self.json_lexer = JsonLexer(**lexer_options)
-        self.css_lexer = CssLexer(**lexer_options)
-        self.xml_lexer = XmlLexer(**lexer_options)
-        self.yaml_lexer = YamlLexer(**lexer_options)
-        self.ruby_lexer = RubyLexer(**lexer_options)
-        self.php_lexer = PhpLexer(**lexer_options)
-        self.cpp_lexer = CppLexer(**lexer_options)
-        self.c_lexer = CLexer(**lexer_options)
-        self.rust_lexer = RustLexer(**lexer_options)
-        self.go_lexer = GoLexer(**lexer_options)
-        self.csharp_lexer = CSharpLexer(**lexer_options)
-        self.java_lexer = JavaLexer(**lexer_options)
-        self.makefile_lexer = MakefileLexer(**lexer_options)
-        self.perl_lexer = PerlLexer(**lexer_options)
-        self.typescript_lexer = TypeScriptLexer(**lexer_options)
-        self.swift_lexer = SwiftLexer(**lexer_options)
-        self.kotlin_lexer = KotlinLexer(**lexer_options)
-        self.scala_lexer = ScalaLexer(**lexer_options)
-        self.objc_lexer = ObjectiveCLexer(**lexer_options)
-        self.dart_lexer = DartLexer(**lexer_options)
-        self.markdown_lexer = MarkdownLexer(**lexer_options)
-        self.diff_lexer = DiffLexer(**lexer_options)
+
+        # Create lazy lexers - imports and initialization deferred until first use
+        self.bash_lexer = LazyBashLexer('pygments.lexers', 'BashLexer', **lexer_options)
+        self.javascript_lexer = LazyLexer('pygments.lexers', 'JavascriptLexer', **lexer_options)
+        self.html_lexer = LazyLexer('pygments.lexers', 'HtmlLexer', **lexer_options)
+        self.sql_lexer = LazyLexer('pygments.lexers', 'SqlLexer', **lexer_options)
+        self.json_lexer = LazyLexer('pygments.lexers', 'JsonLexer', **lexer_options)
+        self.css_lexer = LazyLexer('pygments.lexers', 'CssLexer', **lexer_options)
+        self.xml_lexer = LazyLexer('pygments.lexers', 'XmlLexer', **lexer_options)
+        self.yaml_lexer = LazyLexer('pygments.lexers', 'YamlLexer', **lexer_options)
+        self.ruby_lexer = LazyLexer('pygments.lexers', 'RubyLexer', **lexer_options)
+        self.php_lexer = LazyLexer('pygments.lexers', 'PhpLexer', **lexer_options)
+        self.cpp_lexer = LazyLexer('pygments.lexers', 'CppLexer', **lexer_options)
+        self.c_lexer = LazyLexer('pygments.lexers', 'CLexer', **lexer_options)
+        self.rust_lexer = LazyLexer('pygments.lexers', 'RustLexer', **lexer_options)
+        self.go_lexer = LazyLexer('pygments.lexers', 'GoLexer', **lexer_options)
+        self.csharp_lexer = LazyLexer('pygments.lexers', 'CSharpLexer', **lexer_options)
+        self.java_lexer = LazyLexer('pygments.lexers', 'JavaLexer', **lexer_options)
+        self.makefile_lexer = LazyLexer('pygments.lexers', 'MakefileLexer', **lexer_options)
+        self.perl_lexer = LazyLexer('pygments.lexers', 'PerlLexer', **lexer_options)
+        self.typescript_lexer = LazyLexer('pygments.lexers', 'TypeScriptLexer', **lexer_options)
+        self.swift_lexer = LazyLexer('pygments.lexers', 'SwiftLexer', **lexer_options)
+        self.kotlin_lexer = LazyLexer('pygments.lexers', 'KotlinLexer', **lexer_options)
+        self.scala_lexer = LazyLexer('pygments.lexers', 'ScalaLexer', **lexer_options)
+        self.objc_lexer = LazyLexer('pygments.lexers', 'ObjectiveCLexer', **lexer_options)
+        self.dart_lexer = LazyLexer('pygments.lexers', 'DartLexer', **lexer_options)
+        self.markdown_lexer = LazyLexer('pygments.lexers', 'MarkdownLexer', **lexer_options)
+        self.diff_lexer = LazyLexer('pygments.lexers', 'DiffLexer', **lexer_options)
         
         # Map language identifiers to lexers
         self.language_lexers = {
@@ -672,18 +739,31 @@ class PygmentsLexer(Lexer):
         self.fast_pygments_lexer=self.pygments_lexer
         self.fast_pygments_tokenizer=FastPygmentsTokenizer(self.pygments_lexer)
 
-        # Instantiate the Bash lexer.
-        self.bash_lexer = BashLexer(
-            stripnl=False,
-            stripall=False,
-            ensurenl=False,
-        )
-        self.fast_bash_lexer=self.bash_lexer
-        self.fast_bash_tokenizer=FastPygmentsTokenizer(self.bash_lexer)
+        # Create lazy Bash lexer and tokenizer - only initialized when needed
+        self._lazy_bash_lexer = None
+        self._lazy_bash_tokenizer = None
 
         # Create syntax sync instance.
         self.syntax_sync = syntax_sync or RegexSync.from_pygments_lexer_cls(pygments_lexer_cls)
 
+    @property
+    def fast_bash_lexer(self):
+        if self._lazy_bash_lexer is None:
+            self._lazy_bash_lexer = LazyBashLexer(
+                'pygments.lexers',
+                'BashLexer',
+                stripnl=False,
+                stripall=False,
+                ensurenl=False,
+            )
+        return self._lazy_bash_lexer
+
+    @property  
+    def fast_bash_tokenizer(self):
+        if self._lazy_bash_tokenizer is None:
+            self._lazy_bash_tokenizer = FastPygmentsTokenizer(self.fast_bash_lexer)
+        return self._lazy_bash_tokenizer
+
     def get_lexer(self, document):
         text = document.text
         if text.startswith("!"):
@@ -826,3 +906,34 @@ class PygmentsLexer(Lexer):
             return []
         self.old_text=document.text#For speed's sake: Ryan Burgert
         return get_line
+
+
+class LazyPygmentsLexer(Lexer):
+    """
+    Lazy wrapper for PygmentsLexer that defers lexer imports until first use.
+    This class was Written by Claude, Aug 5 2025. Resulted in massive pterm boot speed boost. Pygments initializations were taking the majority of the time.
+    """
+    
+    def __init__(self):
+        self._real_lexer = None
+    
+    def _get_real_lexer(self):
+        if self._real_lexer is None:
+            # Import only when needed
+            import six
+            if six.PY2:
+                from pygments.lexers import PythonLexer
+                lexer_class = PythonLexer
+            else:
+                from pygments.lexers import Python3Lexer as PythonLexer
+                lexer_class = PythonLexer
+            
+            # Create the actual PygmentsLexer
+            self._real_lexer = PygmentsLexer(lexer_class)
+        return self._real_lexer
+    
+    def lex_document(self, cli, document):
+        return self._get_real_lexer().lex_document(cli, document)
+    
+    def __getattr__(self, name):
+        return getattr(self._get_real_lexer(), name)

{rp-0.1.1303 → rp-0.1.1305}/rp/prompt_toolkit/terminal/vt100_output.py

@@ -424,15 +424,6 @@ class Vt100_Output(Output):
         assert stdout.isatty()
         def get_size():
             rows, columns = _get_size(stdout.fileno())
-            import rp.r_iterm_comm as ric
-            top_space=ric.options['top_space']
-            top_space/=100
-            top_space*=rows
-            top_space=int(top_space)
-            min_rows=ric.options['min_bot_space']
-            if top_space>0:
-                rows=max(min_rows,rows-top_space)
-
             # If terminal (incorrectly) reports its size as 0, pick a reasonable default.
             # See https://github.com/ipython/ipython/issues/10071
             return Size(rows=(rows or 24), columns=(columns or 80))