rp 0.1.1087__tar.gz → 0.1.1088__tar.gz

{rp-0.1.1087 → rp-0.1.1088}/PKG-INFO

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

{rp-0.1.1087 → rp-0.1.1088}/rp/r.py

@@ -12511,6 +12511,10 @@ xrange=range  # To make it more compatiable when i copypaste py2 code
 term='pseudo_terminal(locals(),globals())'# For easy access: exec(term). Can use in the middle of other methods!
 
 def is_valid_python_syntax(code,mode='exec'):
+    """
+    Returns True if the code is valid python syntax, False otherwise.
+    The 'mode' specifies the type of python code - 'exec' is a superset of 'eval'.
+    """
     assert isinstance(code,str),'Code should be a string'
     import ast, traceback
     valid = True
@@ -12521,6 +12525,10 @@ def is_valid_python_syntax(code,mode='exec'):
         valid = False
     return valid
 
+def _is_valid_exeval_python_syntax(code, mode):
+    code, _ = _parse_exeval_code(code)
+    return is_valid_python_syntax(code)
+
 
 def is_valid_shell_syntax(code,*, silent=True, command=None):
     """
@@ -12591,22 +12599,221 @@ _ipython_exeval=None
 
 # region This section MUST come last! This is for if we're running the 'r' class as the main thread (runs pseudo_terminal)―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
 
+
+class _ExevalDirective:
+    def __init__(self, line: str):
+        self.command, self.args = self.parse(line)
+
+    @staticmethod
+    def parse(directive_line):
+        """
+        Validates that all directives are supported by exeval.
+        Currently supported:
+            %return <var namet
+            %private_scope
+        """
+
+        assert isinstance(directive_line, str)
+
+        try:
+            if directive_line == "private_scope":
+                return directive_line, ""
+
+            command, args = directive_line.split(maxsplit=1)
+
+            if command == "return":
+                assert args.strip(), "The '%return ...' directive must specify a variable name"
+                return command, args
+
+            if command in "prepend_code append_code".split():
+                assert args.strip(), "The '%s ...' directive must specify a python expression, not an empty string"%command
+                assert is_valid_python_syntax(args, 'eval'), "The '%%command ...' directive was given invalid python eval syntax: "%command+repr(args)
+                return command, args
+
+        except Exception:
+            raise ValueError("Invalid exeval directive line: " + repr('%'+directive_line))
+
+        raise ValueError("Invalid exeval directive line: " + repr('%'+directive_line))
+
+    def __str__(self):
+        return (self.command + " " + self.args).strip()
+
+    def __repr__(self):
+        return "rp.r._ExevalDirective(%s)" % repr(str(self))
+
+    def __eq__(self, x):
+        """
+        Allows checks such as 
+            assert 'private_scope' in [_ExevalDirective('private_scope')]
+        To make code more concise
+        """
+        return str(self) == str(x)
+
+
+def _parse_exeval_code(code:str):
+    """
+    Used to allow exeval to use python code with lines that start with %, called 'directives'
+
+    Directives are a set of single-line commands at the beginning of the code that start with a '%' symbol.
+    The function extracts these directives and the remaining code, returning both.
+
+    Parameters:
+        - code (str): A string containing the full code block, starting with directives prefixed by '%'.
+
+    Returns:
+        - tuple: A length-2 tuple containing a string and a list
+            1. The python code after the directives (a string)
+            2. A list of _ExevalDirective objects
+
+    Examples:
+        >>> code_block = '''
+            %return 123
+            print('Hello, world!')
+            for i in range(5):
+                print(i)
+            '''
+        >>> code, directives = _parse_exeval_code(code_block)
+        >>> print(directives)
+        ['return 123']
+        >>> print(code)
+        print('Hello, world!')
+        for i in range(5):
+            print(i)
+    """
+
+    #Iterate over each line exactly once
+    lines = code.splitlines()
+
+    directives = []
+    code_out = lines[:]
+
+    for line in lines:
+        strip = line.strip()
+
+        if strip: #Ignore empty directive lines
+            if not strip.startswith('%'):
+                break
+
+            directive_line = strip[1:]
+
+            if directive_line: #Ignore empty directives
+                directive = _ExevalDirective(directive_line)
+                directives.append(directive)
+
+        del code_out[0]
+
+    code_out = '\n'.join(code_out)
+
+    return code_out, directives
+
+
 def exeval(code:str, scope=None):
     """
     Performs either exec(code) or eval(code) and returns the result
     The code will be patched into the linecache - so you can get informative stack traces from it!
     By default it uses the scope of the caller
+
+    The function supports directives at the top of the code block, prefixed with a '%' symbol.
+    Supported directives:
+        - 'return <variable_name>': Allows specifying a variable to be returned from the executed code's scope.
+              This allows you to use exec code 
+        - 'private_scope': Creates a private copy of the scope before executing the code for better concurrency.
+        - 'prepend_code <python_expression>': Prepends some code to your command, specified by a given python expression
+        - 'append_code <python_expression>': Just like like prepend_code, except the code is added to the end instead of the beginning
+
+    Parameters:
+        - code (str): The python code string to be executed or evaluated, with possible additional directive lines at the top.
+        - scope (dict, optional): The scope in which to execute or evaluate the code.
+                                  If not provided, the caller's scope is used.
+
+    Returns:
+        - The result of the executed or evaluated code.
+          If the 'return' directive is used, the value of the specified variable is returned.
+
+    Raises:
+        - KeyError: If the 'return' directive is used and the specified variable is not found in the scope.
+        - Any exception raised during the execution or evaluation of the code.
+
+    Example (return <variable_name> directive):
+        >>> code = '''
+            %return z
+            a = 1
+            b = 2
+            z = a + b
+            '''
+        >>> result = exeval(code)
+        >>> print(result)
+        3
+
+    Example (private_scope directive):
+        >>> scope = {'a' : 0}
+        >>> exeval('''
+            %private_scope
+            a = 1
+            print(a)
+            ''', scope)
+        1
+        >>> exeval('a', scope)
+        0
+        >>> exeval('a = 1', scope)
+        >>> exeval('a', scope)
+        1
+
+    Example (prepend_code directive):
+        >>> exeval('%prepend_code rp.load_text_file("code.py")')
+
+    Example (prepend_code directive):
+        >>> code = '''
+            %prepend_code "def greet(name): return 'Hello, ' + name"
+            print(greet("Alice"))
+            '''
+        >>> exeval(code)
+        Hello, Alice
+
+    Example (append_code directive):
+        >>> exeval('%prepend_code rp.load_text_file("code.py")')
+
+    Example (append_code directive):
+        >>> code = '''
+            %append_code "result = multiply(3, 4)"
+            %return result
+            def multiply(a, b):
+                return a * b
+            '''
+        >>> result = exeval(code)
+        >>> print(result)
+        12
     """
 
+    code, directives = _parse_exeval_code(code)
+
     if scope is None:
         #Execute code in the scope of the caller
         scope=get_scope(1)
 
+    for directive in directives:
+        if directive == 'private_scope':
+            # Create a private copy of the scope so that we don't change variables. Good for concurrency when returning results
+            scope = scope.copy()
+        if directive.command in 'prepend_code append_code'.split():
+            sourced_code = exeval(directive.args, scope)
+
+            assert isinstance(sourced_code, str), "The %s directive returned a non-string result: %s"%(repr(directive), type(sourced_code))
+            if   directive.command=='prepend_code': code = sourced_code + "\n" + code
+            elif directive.command=='append_code' : code = code + "\n" + sourced_code
+
     result, error = _pterm_exeval(code, scope)
 
     if error is not None:
         raise error
 
+    for directive in directives:
+        if directive.command == 'return':
+            return_directive_var_name = directive.args
+            if return_directive_var_name not in scope:
+                raise KeyError("rp.exeval return directive: cannot find variable "+repr(return_directive_var_name))
+            result = scope[return_directive_var_name]
+
     return result
 
 def _pterm_exeval(code,*dicts,exec=exec,eval=eval,tictoc=False,profile=False,ipython=False):
@@ -19956,8 +20163,8 @@ def cv_alpha_weighted_gauss_blur(image,sigma):
         >>> display_alpha_image(
         >>>     grid_concatenated_images(
         >>>         [
-        >>>             [test_image,alpha_blurred, regular_blurred],
-        >>>             [None]+as_rgb_images([alpha_blurred, regular_blurred]),
+        >>>             [test_image, alpha_blurred, regular_blurred],
+        >>>             as_rgb_images([test_image, alpha_blurred, regular_blurred]),
         >>>         ]
         >>>     ),
         >>> )
@@ -25100,21 +25307,56 @@ def copy_paths(
     )
 
 
-def get_path_parent(path_or_url:str):
+def get_path_parent(path_or_url:str, levels=1):
     """
     Retrieve the parent directory or URL of the given path or URL.
     
     Examples:
-        get_path_parent('oaijsd/odjf/aoijf/sdojif.ojf')      -> 'oaijsd/odjf/aoijf'
-        get_path_parent('/')                                 -> '/'
-        get_path_parent('/apsokd')                           -> '/'
-        get_path_parent('/apsokd.asd')                       -> '/'
-        get_path_parent('/aps/asda/sokd.asd')                -> '/aps/asda'
-        get_path_parent('http://www.example.com/path/to')    -> 'http://www.example.com/path'
-        get_path_parent('http://www.example.com/?query')     -> 'http://www.example.com/'
-        get_path_parent('http://www.example.com/')           -> 'http://www.example.com/'
-        get_path_parent('s3://bucket/key/to/object')         -> 's3://bucket/key/to'
-    """
+        >>> get_path_parent('oaijsd/odjf/aoijf/sdojif.ojf')      -> 'oaijsd/odjf/aoijf'
+        >>> get_path_parent('/')                                 -> '/'
+        >>> get_path_parent('/apsokd')                           -> '/'
+        >>> get_path_parent('/apsokd.asd')                       -> '/'
+        >>> get_path_parent('/aps/asda/sokd.asd')                -> '/aps/asda'
+        >>> get_path_parent('http://www.example.com/path/to')    -> 'http://www.example.com/path'
+        >>> get_path_parent('http://www.example.com/?query')     -> 'http://www.example.com/'
+        >>> get_path_parent('http://www.example.com/')           -> 'http://www.example.com/'
+        >>> get_path_parent('s3://bucket/key/to/object')         -> 's3://bucket/key/to'
+
+    Examples:
+        >>> #With paths:
+        >>> path =                        '/opt/homebrew/lib/python3.10/site-packages/rp'
+        >>> get_path_parent(path,0  )  ->  /opt/homebrew/lib/python3.10/site-packages/rp
+        >>> get_path_parent(path    )  ->  /opt/homebrew/lib/python3.10/site-packages
+        >>> get_path_parent(path,1  )  ->  /opt/homebrew/lib/python3.10/site-packages
+        >>> get_path_parent(path,2  )  ->  /opt/homebrew/lib/python3.10
+        >>> get_path_parent(path,3  )  ->  /opt/homebrew/lib
+        >>> get_path_parent(path,5  )  ->  /opt
+        >>> get_path_parent(path,6  )  ->  /
+        >>> get_path_parent(path,7  )  ->  /
+        >>> get_path_parent(path,700)  ->  /
+
+        >>> #With URLs:
+        >>> path =                         'https://huggingface.co/datasets/OneOverZero/MAGICK/commit/abcdefg'
+        >>> get_path_parent(path,0  )  ->   https://huggingface.co/datasets/OneOverZero/MAGICK/commit/abcdefg
+        >>> get_path_parent(path    )  ->   https://huggingface.co/datasets/OneOverZero/MAGICK/commit
+        >>> get_path_parent(path,1  )  ->   https://huggingface.co/datasets/OneOverZero/MAGICK/commit
+        >>> get_path_parent(path,2  )  ->   https://huggingface.co/datasets/OneOverZero/MAGICK
+        >>> get_path_parent(path,3  )  ->   https://huggingface.co/datasets/OneOverZero
+        >>> get_path_parent(path,4  )  ->   https://huggingface.co/datasets
+        >>> get_path_parent(path,5  )  ->   https://huggingface.co/
+        >>> get_path_parent(path,6  )  ->   https://huggingface.co/
+        >>> get_path_parent(path,7  )  ->   https://huggingface.co/
+        >>> get_path_parent(path,700)  ->   https://huggingface.co/
+    """
+
+
+    assert levels>=0
+    if levels==0:
+        return path_or_url
+    if levels>1:
+        for level in range(levels):
+            path_or_url = get_path_parent(path_or_url)
+        return path_or_url
     
     # Parse the input
     from urllib.parse import urlparse, urlunparse
@@ -25133,9 +25375,9 @@ get_file_folder=get_path_parent#Synonyms that might make more sense to read in t
 get_file_directory=get_path_parent
 get_parent_directory=get_parent_folder=get_path_parent
 
-def get_paths_parents(*paths_or_urls):
+def get_paths_parents(*paths_or_urls, levels=1):
     "Plural of get_path_parent"
-    return [get_path_parent(path) for path in detuple(paths_or_urls)]
+    return [get_path_parent(path, levels) for path in detuple(paths_or_urls)]
 
 def make_directory(path):
     """
@@ -35216,6 +35458,9 @@ def type_string_with_keyboard(s, time_per_stroke=1/30):
         elif character=='\x1b':
             keyboard.press(Key.esc)
             keyboard.release(Key.esc)
+        elif character=='\b':
+            keyboard.press(Key.backspace)
+            keyboard.release(Key.backspace)
         else:
             keyboard.press(character)
             keyboard.release(character)

rp-0.1.1088/rp/version.py

@@ -0,0 +1 @@
+1088

{rp-0.1.1087 → rp-0.1.1088}/rp/web_evaluator.py

@@ -52,11 +52,11 @@ class Evaluation:
     
     It includes the following attributes:
         - code: The original Python code that was executed.
-        - value: The return value of the executed code (if it didn't error)
+        - value: The return value of the executed code (if it didn't error and is_eval)
         - error: The exception object if an error occurred during execution.
         - errored: A boolean indicating whether an error occurred.
         - is_eval: A boolean indicating whether the code was executed using eval() (as opposed to exec()).
-        - is_exec: A boolean indicating whether the code was executed using exec().
+        - is_exec: A boolean indicating whether the code was executed using exec(). Will be (not is_eval)
     The `error` and `value` attributes are not always present - 
         but you can determine if they are from other attributes (see `create`'s docstring)
 
@@ -102,7 +102,7 @@ class Evaluation:
         self.is_exec=False
         self.errored=False
         try:
-            if rp.is_valid_python_syntax(self.code,mode='eval'):
+            if rp.r._is_valid_exeval_python_syntax(self.code,mode='eval'):
                 self.is_eval=True
                 self.value=self._exeval(self.code,scope,sync)
             else:
@@ -225,9 +225,6 @@ def _HandlerMaker(scope:dict=None, base_class=SimpleHTTPRequestHandler):
 
             return should_handle
 
-        #TODO:
-        #    Multithreaded
-
         def handle_web_query(self):
             if not self.has_path_prefix("/webeval/web"):
                 return False
@@ -363,7 +360,9 @@ def _HandlerMaker(scope:dict=None, base_class=SimpleHTTPRequestHandler):
 class ThreadingHTTPServer(ThreadingMixIn, HTTPServer):
     pass
 
-def run_server(server_port:int=None,scope:dict=None, handler_base_class=SimpleHTTPRequestHandler):
+def run_server(server_port:int=None,
+               scope:dict=None,
+               handler_base_class=SimpleHTTPRequestHandler):
     """
     Set handler_base_class = SimpleHTTPRequestHandler to make it a fileserver + python-to-python server
     Set handler_base_class = BaseHTTPRequestHandler to make it a python-to-python-only server (no fileserver)
@@ -524,7 +523,78 @@ class Client:
             >>> v=[x.value for x in l if not x.errored]
             >>> # result: v=[1,2]
 
-        TODO: Allow multiple code's to be passed in one request, which will be processed by the server as multiple Evaluation objects. Can decrease the latency by reducing number of round-trips to and from the server
+        EXEVAL DIRECTIVES:
+            [I may remove this documentation in the future, as rp.exeval's docstring has a near-duplicate of this information]
+
+            The Client class uses the `exeval` function internally to execute code on the server. The `exeval` function
+            supports directives that provide additional functionality (please see rp.exeval for a full list):
+
+            1. `%return <variable_name>`: Allows specifying a variable to be returned from the executed code's scope.
+               This is useful when executing code that cannot be evaluated as an expression.
+
+               Example:
+                   >>> code = '''
+                       %return result
+                       a = 10
+                       b = 20
+                       result = a + b
+                       '''
+                   >>> result = client.evaluate(code)
+                   >>> print(result.value)
+                   30
+
+               Example:
+                   >>> code = '''
+                       %return output
+                       %private_scope
+                       def f():
+                           import time
+                           return time.time()
+                       output = f()
+                       '''
+                   >>> result = client.evaluate(code)
+                   >>> print(result.value)
+                   1724402196.466829
+
+            2. `%private_scope`: Creates a private copy of the scope before executing the code. This directive ensures that
+               variable changes made during code execution are not persistent between requests. It is particularly important
+               when `sync=False` to prevent unintended side effects and maintain the integrity of the server's scope.
+
+               Example (without `%private_scope`):
+                   >>> code1 = 'x = 10'
+                   >>> code2 = 'print(x)'
+                   >>> client.evaluate(code1)
+                   >>> client.evaluate(code2)
+                   10
+
+               Example (with `%private_scope`):
+                   >>> code1 = '''
+                       %private_scope
+                       x = 10
+                       '''
+                   >>> code2 = 'print(x)'
+                   >>> client.evaluate(code1)
+                   >>> client.evaluate(code2).error
+                   NameError: name 'x' is not defined
+
+               In the example without `%private_scope`, the variable `x` is persisted between requests, allowing the second
+               request to access its value. However, with `%private_scope`, each request has its own isolated scope, and
+               variables defined in one request are not accessible in subsequent requests.
+
+            3. `prepend_code <python_expression>`: Prepends·some·code·to·your·command,·specified·by·a·given·python·expression.
+               This allows for creation of variables in the given scope from server-side code, which cannot happen without this directive.
+
+               Example:
+                    >>> exeval('%prepend_code rp.load_text_file("code.py")')
+
+               (see rp.exeval's docstring for more examples)
+            
+            3. `append_code` <python_expression>`: Just like prepend_code, but adds code to the end instead of the beginning
+
+               Example:
+                    >>> exeval('%append_code rp.load_text_file("code.py")')
+
+               (see rp.exeval's docstring for more examples)
         """
         
 

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

@@ -0,0 +1,11 @@
+Metadata-Version: 1.0
+Name: rp
+Version: 0.1.1088
+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.1088/version.py

@@ -0,0 +1 @@
+1088

rp-0.1.1087/rp/version.py

@@ -1 +0,0 @@
-1087

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

@@ -1,11 +0,0 @@
-Metadata-Version: 1.0
-Name: rp
-Version: 0.1.1087
-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.1087/version.py

@@ -1 +0,0 @@
-1087