rp 0.1.1025__tar.gz → 0.1.1027__tar.gz

{rp-0.1.1025 → rp-0.1.1027}/PKG-INFO

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

{rp-0.1.1025 → rp-0.1.1027}/rp/r.py

@@ -8267,10 +8267,12 @@ sync_sort=sync_sorted#For backwards compatiability
 
 def starts_with_any(string,*prefixes):
     prefixes=detuple(prefixes)
+    if isinstance(prefixes,str): prefixes=[prefixes]
     return any(string.startswith(x) for x in prefixes)
 
 def ends_with_any(string,*suffixes):
     suffixes=detuple(suffixes)
+    if isinstance(suffixes,str): suffixes=[suffixes]
     return any(string.endswith(x) for x in suffixes)
 
     
@@ -10532,6 +10534,58 @@ def is_valid_python_syntax(code,mode='exec'):
         valid = False
     return valid
 
+
+def is_valid_shell_syntax(code,*, silent=True, command=None):
+    """
+    Returns True if the code is valid shell syntax for your default shell. If command is specified (such as '/bin/zsh' or rp.get_default_shell()), checks that shell instead.
+
+    EXAMPLE:
+        >>> is_valid_shell_syntax('asoidj')
+        ans = True
+        >>> is_valid_shell_syntax('asoidj("')
+        ans = False
+    """
+    import subprocess
+    
+    if command is None:
+        command=get_default_shell()
+    else:
+        assert isinstance(command,str)
+
+    try:
+        # Running the shell code with 'sh -n' which checks for syntax without execution
+        process = subprocess.run(
+            [command, "-n"], input=code, text=True, stderr=subprocess.PIPE, check=True
+        )
+        # If the shell command succeeds without error, the syntax is valid
+        return True
+    except subprocess.CalledProcessError as e:
+        # If there's a syntax error, print the error and return False
+        if not silent:
+            print("Syntax error:", e.stderr)
+        return False
+
+def is_valid_sh_syntax(code, *,silent=True, command="sh"):
+    """Returns True if the code is valid bash syntax, False otherwise. If silent=False, will print out more information."""
+    return is_valid_shell_syntax(code, silent=silent, command=command)
+
+def is_valid_bash_syntax(code, *,silent=True, command="bash"):
+    """Returns True if the code is valid bash syntax, False otherwise. If silent=False, will print out more information."""
+    return is_valid_shell_syntax(code, silent=silent, command=command)
+
+
+def is_valid_zsh_syntax(code, *,silent=True, command="zsh"):
+    """Returns True if the code is valid bash syntax, False otherwise. If silent=False, will print out more information."""
+    return is_valid_shell_syntax(code, silent=silent, command=command)
+
+
+def get_default_shell():
+    """Returns the path to the user's default shell."""
+    return os.environ.get('SHELL', '/bin/sh')  # Fallback to '/bin/sh' if SHELL is not set
+
+
+
+
 def _ipython_exeval_maker(scope={}):
     pip_import('IPython','ipython')#Make sure we have ipython
     from IPython.terminal.embed import InteractiveShellEmbed as Shell
@@ -12368,7 +12422,8 @@ def pseudo_terminal(*dicts,get_user_input=python_input,modifier=None,style=pseud
             nonlocal error,display_help_message_on_error,error_message_that_caused_exception
             if display_help_message_on_error:
                 display_help_message_on_error=False
-                fansi_print("""Sorry, but that command caused an error that pseudo_terminal couldn't fix! Command aborted.
+                if False: #Nah, don't need this anymore lol
+                    fansi_print("""Sorry, but that command caused an error that pseudo_terminal couldn't fix! Command aborted.
             Type 'HELP' for instructions on how to use pseudo_terminal in general.
             To see the full traceback of any error, type either 'MORE' or 'MMORE' (or alt+m as a shortcut).
             NOTE: This will be the last time you see this message, unless you enter 'HELP' without quotes.""",'red','bold')

{rp-0.1.1025 → rp-0.1.1027}/rp/rp_ptpython/completer.py

@@ -36,6 +36,10 @@ def get_all_importable_module_names():
 from threading import Thread
 Thread(target=get_all_importable_module_names).start()
 Thread(target=lambda: __import__('rp').r._get_cached_system_commands).start()
+
+
+MAX_SORTING_PRIORITY=999999999
+sorting_priorities={}
     
 
 _get_apt_completions_cache=None
@@ -161,6 +165,7 @@ class PythonCompleter(Completer):
             char_before_cursor.isalnum() or char_before_cursor in '_.')
 
     def _get_completions(self, document, complete_event,force=False):# When force is true it acts like the original ptpython autocomplete
+      sorting_priorities.clear()
       import warnings
       with warnings.catch_warnings():
         warnings.simplefilter('ignore')
@@ -168,9 +173,14 @@ class PythonCompleter(Completer):
         global old_origin,candidates
         origin=document.get_word_before_cursor()
 
-        def yield_from_candidates(candidates:list):
-            for c in candidates:
-                yield Completion(text=c,start_position=-len(origin),display=c);
+        def yield_from_candidates(candidates:list,priority=None):
+            if priority is None:
+                priority=[MAX_SORTING_PRIORITY]*len(candidates)
+            for c,p in zip(candidates,priority):
+                completion=Completion(text=c,start_position=-len(origin),display=c);
+                sorting_priorities[c]=p
+                # print(c,p)
+                yield completion
         import rp.r_iterm_comm as ric
         before_line=document.current_line_before_cursor
 
@@ -247,10 +257,71 @@ class PythonCompleter(Completer):
         #     return#Don't autocomplete function paramater names
 
         from rp import starts_with_any
-        if starts_with_any(before_line,'CD ','TAKE ','MKDIR ') and not ('\n' in before) and not after:#not after and not '\n' in before and re.fullmatch(before_line):
+
+        def pathmod(entry):
+            if isinstance(entry,str):
+                if path_before_cursor is not None:
+                    #For completing CD and TAKE etc
+                    entry=entry[len(path_before_cursor):]
+                elif entry.startswith('./'): 
+                    #For completing in strings primarily
+                    #This is just bloat
+                    entry =entry[len('./'):]
+                return entry
+            out = entry.path
+            if entry.is_dir():
+                out+='/'
+            assert isinstance(out,str)
+            return pathmod(out)
+
+        def pathsmod(entries,priority=lambda x:MAX_SORTING_PRIORITY):
+            mods=[]
+            pris=[]
+            for x in entries:
+                mods.append(pathmod(x))
+                pris.append(priority(x))
+            return mods,pris
+
+        path_before_cursor=None
+        def get_path_before_cursor():
+            nonlocal path_before_cursor #Cache this
+
+            #Assume we're like 'TAKE /path'  or  'CAT ./path' etc - we have a space after the first word
+            assert ' ' in before_line
+            first_word=before_line.split()[0]
+            line=before_line
+            line=line[len(first_word):]
+            line=line.lstrip()
+            if not line:
+                path= '.'
+            elif line.endswith('/'):
+                path= line
+            elif '/' in line:
+                path= '/'.join(line.split('/')[:-1])
+            else:
+                path= line
+
+            import rp
+            if rp.path_exists(path):
+                path_before_cursor = path
+            else:
+                #Don't crash, hack here. No reason to return '.', really, other than that. Cant pass bad path to scandir.
+                path_before_cursor = '.'
+
+            return path_before_cursor
+
+
+                
+        if starts_with_any(before_line,'CD ') and not ('\n' in before) and not after:#not after and not '\n' in before and re.fullmatch(before_line):
+            import rp
+            import os
+            from rp import is_a_directory
+            yield from yield_from_candidates(*pathsmod(x for x in os.scandir(get_path_before_cursor()) if x.is_dir()))
+            return 
+        if starts_with_any(before_line,'TAKE ','MKDIR ') and not ('\n' in before) and not after:#not after and not '\n' in before and re.fullmatch(before_line):
             import os
             from rp import is_a_directory
-            yield from yield_from_candidates([x for x in os.listdir() if is_a_directory(x)])
+            yield from yield_from_candidates(*pathsmod(os.scandir(get_path_before_cursor()), priority= lambda x:not x.is_dir()))
             return 
         if starts_with_any(before_line,'PYM ','APYM ') and not ('\n' in before) and not after:#not after and not '\n' in before and re.fullmatch(before_line):
             def get_module_names():
@@ -261,12 +332,13 @@ class PythonCompleter(Completer):
             return 
         if starts_with_any(before_line,'RN ','RM ','VIM ','OPEN ','FD ','WANS ','MV ','PIP ') and not ('\n' in before) and not after:#not after and not '\n' in before and re.fullmatch(before_line):
             import os
-            yield from yield_from_candidates(os.listdir())
+            yield from yield_from_candidates(*pathsmod(os.scandir(get_path_before_cursor())))
             return 
         if re.fullmatch(r'(CAT |NCAT |CCAT |OPEN |ACAT |TAB |RUN |PY |APY |PYM |APYM ).*',before) and not ('\n' in before) and not after:#not after and not '\n' in before and re.fullmatch(before_line):
             import os
             from rp import is_a_file
-            yield from yield_from_candidates([x for x in os.listdir() if is_a_file(x)])
+            import rp
+            yield from yield_from_candidates(*pathsmod(os.scandir(get_path_before_cursor()), priority= lambda x: x.is_dir())) #Put directories last but do include them
             return 
         if re.fullmatch(r'.*\`\w*',before_line)\
             or (before_line.startswith('RUN ') and not ('\n' in before) and not after):#not after and not '\n' in before and re.fullmatch(before_line):
@@ -334,7 +406,20 @@ class PythonCompleter(Completer):
 
             # Do Jedi Python completions.
             if complete_event.completion_requested or self._complete_python_while_typing(document):
-                doc=Document(document.text,document.cursor_position-(origin[::-1].find('.') if '.' in origin else len(origin)),document.selection)
+                
+                cursor_position=document.cursor_position
+
+                if not '/' in origin:
+                    #If we're completing a path, don't modify this.
+                    #Otherwise, please grab as many completions as we can so we can efficiently backtrack through them
+                    cursor_position-=(origin[::-1].find(".") if "." in origin else len(origin))   #NOT SURE WHAT THIS WAS FOR (april 19 2024) --- Disabling it seems to do nothing?? OH wait...I think I know what this is for...its to make sure we get ALL the completions so our code can handle getting subsets faster. Re-enabling.
+
+                doc = Document(
+                    document.text,
+                    cursor_position,
+                    document.selection,
+                )
+
                 script = get_jedi_script_from_document(doc, self.get_locals(), self.get_globals())
                 # print(script)
                 pos=document.cursor_position-len(origin)+1
@@ -511,14 +596,20 @@ class PythonCompleter(Completer):
             # 1. Items starting with '.' come last.
             # 2. Items starting with '_' come next.
             # 3. Other items come first.
+            orig = x
             if x.startswith('.'):
-                output = 2  # Highest sort value for items starting with '.'
+                if origin.startswith('.'):
+                    #If explicitly looking for hidden file paths, put it first
+                    output = -1
+                else:
+                    #If not explicitly looking for that, put it last
+                    output = 1
             elif x.startswith('_'):
                 if origin.startswith('_'):
                     #If explicitly looking for privates, put it first
                     output = -1
                 else:
-                    #If not explicitly looking for privates, put it last
+                    #If not explicitly looking for that, put it last
                     output = 1
             else:
                 output = 0  # Lowest sort value for other items
@@ -527,12 +618,55 @@ class PythonCompleter(Completer):
             user_created_priority = 0 if x in user_created_var_names else 1
 
             output = (output, user_created_priority)
+            output = (output, sorting_priorities.get(orig,MAX_SORTING_PRIORITY))
 
             return output
+
+        out_completions=[]
+
+        # print(sorting_priorities)
+
         # Single loop processing all candidates, sorted by the custom key
         for x in sorted(ric.current_candidates, key=sorting_key):
-            yield Completion(text=x, start_position=-len(post_period_origin), display=x)
+            if x.endswith("'") or x.endswith('"'): x=x[:-1] #Autocompleted paths in strings are a bit buggy right now
+
+            #When completing 'System/|' origin is just '/'
+
+            def unhidden_path(x):
+                o=x
+                x=x.strip()
+                while x[0] in '/':
+                    x=x[1:]
+                if x.startswith('.'):
+                    return x[1:]
+                return o
+
+            #TODO: THis was edited on MACX to give path completion for CD etc on April 19 2024. It's very sloppy and full of bugs and really ugly, done in los angeles. TODO: Undo this commit and make it prettier! 
+            if x.startswith('/') and (not '/' in before_line or before_line.endswith('/')):
+                x=x[1:]
+                
+            text=x
+            display=x
+
+            if x.strip().endswith('/'):
+                #Its annoying when folders are completed with /'s because then when we type tab it goes away
+                #But if we type / we get folder// instead.
+                #Let the user type the /
+                text=text.strip()[:-1]
+                if '/' in origin:
+                    #Make sure dividers are right
+                    text = "/" + text
+
+            if '.' in x and before_line.endswith('.'):
+                #Don't complete .g to ..git   or   'rp/.' to 'rp/..git' make it 'rp/.git' instead
+                text=unhidden_path(text)
+
+            # display=origin #For debugging
+
+
+            out_completions.append(Completion(text=text, start_position=-len(post_period_origin), display=display))
 
+        yield from out_completions
 
         #OLD VERSION BEFORE SORTING_KEY
         # for x in ric.current_candidates:

{rp-0.1.1025 → rp-0.1.1027}/rp/rp_ptpython/key_bindings.py

@@ -3533,6 +3533,42 @@ def load_python_bindings(python_input):
     #     document=buffer.document
     #     current_line=document.current_line
 
+
+    @handle(Keys.BracketedPaste)
+    def _(event):
+        " Pasting from clipboard. "
+        data = event.data
+
+        # Be sure to use \n as line ending.
+        # Some terminals (Like iTerm2) seem to paste \r\n line endings in a
+        # bracketed paste. See: https://github.com/ipython/ipython/issues/9737
+        data = data.replace('\r\n', '\n')
+        data = data.replace('\r', '\n')
+
+        buffer=event.cli.current_buffer
+        document=buffer.document
+        before=document.text_before_cursor
+        after= document.text_after_cursor
+
+        import rp
+        if not data.startswith(' ') and data:
+            first_word=data.split()[0]
+            import rp.r_iterm_comm as ric
+            import keyword
+
+            # Get the list of all Python keywords
+            python_keywords = keyword.kwlist
+
+            if not data.startswith('!') and first_word in rp.r._get_cached_system_commands() and rp.is_valid_shell_syntax(data) and (not rp.is_valid_python_syntax(data) or not first_word in set(ric.globa)|set(python_keywords) ) and not before and not after:
+                #Assume we're pasting a shell command instead 
+                data='!'+data
+            elif before=='1' and not after and not data[0].isnumeric():
+                #Pasting after 1 --> !
+                buffer.delete_before_cursor()
+                buffer.insert_text('!')
+
+        buffer.insert_text(data)
+
     @handle(Keys.ControlD)# Duplicate current line Only applies when there's text, else it will trigger the exit
     def _(event):
         buffer=event.cli.current_buffer

rp-0.1.1027/rp/version.py

@@ -0,0 +1 @@
+1027

rp-0.1.1027/rp.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 1.0
+Name: rp
+Version: 0.1.1027
+Summary: Ryan's Python
+Home-page: https://github.com/RyannDaGreat/Quick-Python
+Author: Ryan Burgert
+Author-email: ryancentralorg@gmail.com
+License: UNKNOWN
+Description: UNKNOWN
+Keywords: not_searchable_yet_go_away_until_later_when_this_is_polished
+Platform: UNKNOWN

rp-0.1.1027/version.py

@@ -0,0 +1 @@
+1027

rp-0.1.1025/rp/version.py

@@ -1 +0,0 @@
-1025

rp-0.1.1025/rp.egg-info/PKG-INFO

@@ -1,11 +0,0 @@
-Metadata-Version: 1.0
-Name: rp
-Version: 0.1.1025
-Summary: Ryan's Python
-Home-page: https://github.com/RyannDaGreat/Quick-Python
-Author: Ryan Burgert
-Author-email: ryancentralorg@gmail.com
-License: UNKNOWN
-Description: UNKNOWN
-Keywords: not_searchable_yet_go_away_until_later_when_this_is_polished
-Platform: UNKNOWN

rp-0.1.1025/version.py

@@ -1 +0,0 @@
-1025