rp 0.1.1215__tar.gz → 0.1.1217__tar.gz

{rp-0.1.1215 → rp-0.1.1217}/PKG-INFO

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

{rp-0.1.1215 → rp-0.1.1217}/rp/r.py

@@ -9336,6 +9336,151 @@ def rebind_globals_to_module(module, *, monkey_patch=False):
     return decorator
 
 
+def globals_macro(func):
+    """
+    Decorator that makes a function's local variables available globally.
+
+    Useful for making reusable cells in a Jupyter notebook.
+    
+    When a function decorated with @globals_macro is called, all local variables created
+    within the function become available in the global namespace after execution.
+    This includes both function parameters and local variables.
+    
+    The global namespace modification is the primary feature of this decorator,
+    intentionally creating side effects by design. Variables defined inside the
+    function will persist after execution.
+    
+    Example (Normal Execution):
+        >>> # Variables don't exist before using the decorator
+        >>> 'x' in globals(), 'y' in globals(), 'z' in globals()
+        (False, False, False)
+        
+        >>> @globals_macro
+        ... def f(x, y):
+        ...     z = x + y
+        >>> f(1, 2)
+        
+        >>> # Variables now exist in the global scope
+        >>> x, y, z
+        (1, 2, 3)
+    
+    Example (With Error):
+        >>> # Variables are still preserved even when an error occurs
+        >>> @globals_macro
+        ... def f(x, y):
+        ...     1/0  # Division by zero error
+        ...     z = x + y  # This line never executes
+        >>> try:
+        ...     f(100, 200)
+        ... except ZeroDivisionError:
+        ...     print("Error caught")
+        Error caught
+        
+        >>> # Parameters are still preserved in the global scope
+        >>> x, y
+        (100, 200)
+        >>> # But z isn't defined since that line never executed
+        >>> 'z' in globals()
+        False
+
+    Example:
+        >>> @globals_macro
+        ... def part_0a():
+        ...     url = "https://www.pupsgonewild.com/s/cc_images/cache_7853498.jpg"
+        ... 
+        ... 
+        ... @globals_macro
+        ... def part_0b():
+        ...     url = "https://mortenhannemose.github.io/assets/img/Lena_1024.png"
+        ... 
+        ... 
+        ... @globals_macro
+        ... def part_0c():
+        ...     url = "https://res.cloudinary.com/lancaster-puppies-laravel/image/upload/$date_!12%252F26%252F2024!/t_lpr-full-transform/t_lpr-date-transform/r_16/v1/default/eoxl4syekwivgrdgze5u?_a=AJAJZWI0"
+        ... 
+        ... 
+        ... @globals_macro
+        ... def part_1():
+        ...     image = load_image(url)
+        ... 
+        ... 
+        ... @globals_macro
+        ... def part_2():
+        ...     images = []
+        ...     for part_0 in [part_0a, part_0b, part_0c]:
+        ...         part_0()
+        ...         part_1()
+        ...         images.append(image)
+        ... 
+        ... 
+        ... @globals_macro
+        ... def part_3():
+        ...     part_2()
+        ...     display_image(horizontally_concatenated_images(images))
+        ... 
+        ... 
+        ... part_3()
+    """
+    import inspect
+    import functools
+    import sys
+    import types
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Get the caller's globals
+        caller_frame = sys._getframe(1)
+        caller_globals = caller_frame.f_globals
+        
+        # Create a dictionary to store function's locals
+        func_locals = {}
+        
+        # First, bind the arguments to parameter names to ensure parameters are captured
+        sig = inspect.signature(func)
+        bound_args = sig.bind(*args, **kwargs)
+        bound_args.apply_defaults()
+        func_locals.update(bound_args.arguments)
+        
+        # Set up trace function to capture variables on each line
+        def trace_func(frame, event, arg):
+            # We're only interested in the function we're decorating
+            if frame.f_code == func.__code__:
+                # Copy all variables from the frame's locals to our dictionary
+                for var_name, value in frame.f_locals.items():
+                    func_locals[var_name] = value
+                # Keep tracing this function
+                return trace_func
+            # Don't trace other functions
+            return None
+            
+        # Set tracing and execute the function
+        original_trace = sys.gettrace()
+        sys.settrace(trace_func)
+        
+        try:
+            # Call the function and get its result
+            result = func(*args, **kwargs)
+            return result
+        except Exception:
+            # Capture the exception info
+            exc_info = sys.exc_info()
+            # Will re-raise after transferring variables
+            raise_later = True
+        finally:
+            # Restore the original trace function
+            sys.settrace(original_trace)
+            
+            # Copy the captured locals to the caller's globals
+            for name, value in func_locals.items():
+                caller_globals[name] = value
+                
+            # If there was an exception, re-raise it
+            if 'raise_later' in locals() and raise_later:
+                raise exc_info[1].with_traceback(exc_info[2])
+    
+    return wrapper
+
+
 def _filter_dict_via_fzf(input_dict,*,preview=None):
     """Uses fzf to select a subset of a dict and returns that dict."""
     #Refactored using GPT4 from a mess: https://chat.openai.com/share/66251028-75eb-4c55-960c-1e7477e34060
@@ -34943,6 +35088,89 @@ def get_scope(frames_back=0):
 
     return {'locals':frame.f_locals, 'globals':frame.f_globals}[scope]
 
+
+def _get_visible_scope(frames_back=0):
+    """
+    Treat the output as read-only! Will include all variables that can be seen from that point.
+
+    Should be an improved form of get_scope, but to avoid breaking other code (just in case), I'm making this a private helper for rp internals.
+    
+    Get the scope of n levels up from the current stack frame,
+    including all globals, locals, and variables from enclosing scopes.
+    
+    Parameters:
+    frames_back (int): How many frames to go up in the stack. 0 means the calling function's frame.
+    
+    Returns:
+    dict: A dictionary with all variables from globals, locals, and enclosing scopes.
+
+    EXAMPLE:
+        >>> import rp
+        ... y=456
+        ... def f():
+        ...     x=123
+        ...     def g():
+        ...         print(rp.repr_kwargs_dict(rp.r._get_visible_scope()))
+        ...     g()
+        ... f()
+        dict(
+             __name__        = '__main__',
+             __doc__         = None,
+             __package__     = None,
+             __loader__      = <_frozen_importlib_external.SourceFileLoader object at 0x104e90530>,
+             __spec__        = None,
+             __annotations__ = {},
+             __builtins__    = <module 'builtins' (built-in)>,
+             __file__        = '/Users/burgert/CleanCode/Sandbox/test.py',
+             __cached__      = None,
+             rp              = <module 'rp' from '/Users/burgert/miniconda3/lib/python3.12/site-packages/rp/__init__.py'>,
+             y               = 456,
+             f               = <function f at 0x104e6e340>,
+             x               = 123,
+             g               = <function f.<locals>.g at 0x104ef5760>,
+        )
+
+    """
+    assert isinstance(frames_back, int), 'frames_back must be an integer'
+    assert frames_back >= 0, 'frames_back cannot be negative'
+
+    import inspect
+
+    frame = inspect.currentframe()
+    frame = frame.f_back  # Don't return the scope for this function
+    for _ in range(frames_back):
+        frame = frame.f_back
+        if frame is None:
+            break
+
+    # Create result dict with both globals and locals
+    result = {}
+    result.update(frame.f_globals)
+    result.update(frame.f_locals)
+    
+    # Check for variables in enclosing scopes
+    current = frame
+    # Handle freevars (variables from enclosing scopes)
+    if hasattr(current, 'f_code') and hasattr(current.f_code, 'co_freevars'):
+        # Get a list of all outer frames
+        frames = []
+        outer = current.f_back
+        while outer:
+            frames.append(outer)
+            outer = outer.f_back
+        
+        # Process each frame from innermost to outermost
+        for outer_frame in frames:
+            if outer_frame.f_locals:
+                # Check each local in the outer frame
+                for name, value in outer_frame.f_locals.items():
+                    # Add it if it's not already in our result
+                    if name not in result:
+                        result[name] = value
+    
+    return result
+
+
 _all_module_names=set()
 def get_all_importable_module_names(use_cache=True):
     """
@@ -40699,7 +40927,7 @@ def validate_tensor_shapes(*, verbose=False, **kwargs):
         return ','.join(map(str, shape))
 
     # Get the caller's scope to find tensor variables
-    caller_scope = get_scope(1)
+    caller_scope = _get_visible_scope(1)
     
     # Separate dimension constraints from tensor form strings
     dim_constraints = {}

{rp-0.1.1215 → rp-0.1.1217}/rp/ryan_vimrc.py

@@ -1067,6 +1067,13 @@ Plugin 'simeji/winresizer' "Use control+e to resize windows
         "    Plugin 'chrisbra/vim-autoread'
         "    :set noautoread
 
+        "ALIGN:
+            Plugin 'junegunn/vim-easy-align'
+            " Start interactive EasyAlign in visual mode (e.g. vipga)
+            xmap ga <Plug>(EasyAlign)
+            " Start interactive EasyAlign for a motion/text object (e.g. gaip)
+            nmap ga <Plug>(EasyAlign)
+
         "AUTOREAD:
         " https://superuser.com/questions/181377/auto-reloading-a-file-in-vim-as-soon-as-it-changes-on-disk
         set autoread                                                                                                                                                                                    

rp-0.1.1217/rp/version.py

@@ -0,0 +1 @@
+1217

{rp-0.1.1215 → rp-0.1.1217}/rp.egg-info/PKG-INFO

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

rp-0.1.1217/version.py

@@ -0,0 +1 @@
+1217

rp-0.1.1215/rp/version.py

@@ -1 +0,0 @@
-1215

rp-0.1.1215/version.py

@@ -1 +0,0 @@
-1215