rp 0.1.1277__tar.gz → 0.1.1278__tar.gz

{rp-0.1.1277 → rp-0.1.1278}/PKG-INFO

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

rp-0.1.1278/rp/libs/peepdis/__init__.py

@@ -0,0 +1,3 @@
+from peepdis.legacy import peep
+
+name = "peep-dis"

rp-0.1.1278/rp/libs/peepdis/core.py

@@ -0,0 +1,225 @@
+from copy import deepcopy
+from inspect import getfullargspec
+from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType
+
+from typing import Any, Callable, Dict, Tuple, Type
+
+from peepdis.preferences import _PreferencesMixin
+from peepdis.datastructures import Arg, ArgDict, Output
+
+
+# TODO: feature to check for state modifications by copying, then running method, then checking equality on attributes
+# TODO: FIX for correct output from debug script
+# TODO: should attrs and methods include builtins or should there be a
+# TODO: verbose=False should exclude anything that's null, and builtins=False should exclude anything that's builtin. Verbose should be used to filter after eval
+# TODO: ensure that forge is only forging positional args
+# TODO: for data structures that contain multiple types, attempt to forge them, maybe using hypothesis strategies?
+
+
+def peep(obj, verbose=False, forge=False):
+    peeper = Peeper(obj)
+    peeper.peep(forge)
+    peeper.print(verbose)
+
+
+class PeeperMixin(dict):
+    def __init__(self, obj):
+        super().__init__()
+        self.obj = deepcopy(obj)
+        self.dir = set(dir(obj))
+
+
+class Peeper(PeeperMixin, _PreferencesMixin):
+    def __init__(self, obj):
+        # TODO: should I replace self with CallablePeeper?
+        super().__init__(obj)
+        self.attrs = dict()
+        self.methods = dict()
+        self.errors = dict()
+        self.builtins = dict()
+
+    def peep(self, forge=False):
+        for name in self.dir:
+            output = self.evaluate(name, forge=forge)
+            self._index(output)
+
+    def results(self, verbose=False):
+        if verbose:
+            return dict(self)
+        else:
+            return {name: self[name] for name in self if name not in self.builtins}
+
+    def print(self, verbose=False):
+        for name, output in self.results(verbose).items():
+            print(*output.get_colored())
+
+    def evaluate(self, name, *args, forge=False, **kwargs) -> Output:
+        attr = getattr(self.obj, name)
+        if not callable(attr):
+            return Output(name, attr)
+        # TODO: consider different paths for builtins
+        unique_callables = (FunctionType, MethodType)
+        builtin_callables = (BuiltinFunctionType, BuiltinMethodType)
+        if isinstance(attr, unique_callables):
+            peeper_class = CallablePeeper
+        else:
+            peeper_class = BuiltinCallablePeeper
+        if name == "plot":
+            a = 5
+        try:
+            peeper = peeper_class(attr)
+            return peeper.evaluate(*args, forge=forge, **kwargs)
+        except Exception as e:
+            if "unsupported callable" in str(e):
+                output_str = "(unsupported callable)"
+                return Output(
+                    name, output_str, callable_=True, unsupported_callable=True
+                )
+            else:
+                raise ValueError(f"Unexpected error for method {name}")
+
+    def _index(self, output: Output):
+        self[output.name] = output
+        if output.builtin:
+            self.builtins[output.name] = self[output.name].value
+        elif output.callable_:
+            self.methods[output.name] = self[output.name].value
+        elif output.error:
+            self.errors[output.name] = self[output.name].value
+        else:
+            self.attrs[output.name] = self[output.name].value
+
+
+class BuiltinCallablePeeper(PeeperMixin):
+    # TODO: will need to merge with CallablePeeper in the future
+    def __init__(self, obj, *args, **kwargs):
+        super().__init__(obj)
+        # TODO: move ArgDict instantiation up here and fix numbering
+
+    def evaluate(self, *args, forge=False, **kwargs) -> Output:
+        # TODO: figure out how to set up args in this case (no access to positional arg names)
+        arg_names = [i for i in range(len(args))]
+        arg_names += list(kwargs.values())
+        self.args = ArgDict(arg_names)
+        self.args.update_positional(*args)
+        self.args.update_kwargs(**kwargs)
+        obj = deepcopy(self.obj)
+        try:
+            output_str = repr(obj(*args, **kwargs))
+        except Exception as e:
+            output_str = repr(e)
+            error = True
+            if "argument" in str(e):
+                args_missing = True
+                if ":" in str(e):
+                    missing_arg_str = output_str.split(":")[1][:-2]
+                    output_str = f"(missing args: {missing_arg_str})"
+                else:
+                    output_str = f"(missing args)"
+            else:
+                args_missing = False
+                output_str = repr(e)
+        else:
+            error = False
+            args_missing = False
+        return Output(
+            obj.__name__,
+            output_str,
+            self.args,
+            callable_=True,
+            error=error,
+            args_missing=args_missing,
+        )
+
+
+class CallablePeeper(PeeperMixin):
+    _ordinary_callables = (FunctionType, MethodType)
+    _builtin_callables = (BuiltinFunctionType, BuiltinMethodType)
+    _forgery_dict = {"int": 0, "str": "abc", "list": [0, 1], "None": None}
+
+    def __init__(self, obj, *args, **kwargs):
+        super().__init__(obj)
+        if isinstance(obj, self._ordinary_callables):
+            self.spec = getfullargspec(obj)    # TODO: test on arrays, dataframes, and sklearn models (seemed to work on sklearn)
+            self.args = ArgDict(self.spec.args)
+            self._collect_args(*args, **kwargs)
+        elif isinstance(obj, self._builtin_callables):
+            self.args = ArgDict([])
+
+    def _collect_args(self, *args, **kwargs):
+        if self.spec.defaults:
+            for i, arg in enumerate(self.spec.defaults[::-1]):
+                self.args[-1 - i].value = arg
+                self.args[-1 - i].method = "default"
+        for i, arg in enumerate(args):
+            self.args[i].value = arg
+            self.args[i].method = "specified"
+        for name, arg in kwargs.items():
+            self.args[name].value = arg
+            self.args[name].method = "specified"
+
+    def evaluate(self, *args, forge=False, **kwargs) -> Output:
+        obj = deepcopy(self.obj)
+        if forge:
+            self.forge_args()
+        self.args.update_positional(*args)
+        self.args.update_kwargs(**kwargs)
+        arg_dict = self.args.generate_args()
+        try:
+            output_str = repr(obj(**arg_dict))
+        except Exception as e:
+            output_str = repr(e)
+            error = True
+            if "missing" in str(e) and "argument" in str(e):
+                missing_arg_str = output_str.split(":")[1][:-2]
+                output_str = f"(missing args: {missing_arg_str})"
+                args_missing = True
+            else:
+                args_missing = False
+                output_str = repr(e)
+        else:
+            error = False
+            args_missing = False
+        return Output(
+            obj.__name__,
+            output_str,
+            self.args,
+            callable_=True,
+            error=error,
+            args_missing=args_missing,
+        )
+
+    def forge_args(self, *args, **kwargs):
+        """ Attempt to generate arguments to call the method """
+        # TODO: currently forging kwargs and causing errors. Only forge positionals
+        type_dict = self._infer_types()
+        self.args.returns = type_dict.pop("returns", None)
+        for name in self.args.null_args:
+            type_ = type_dict.get(name, None)
+            if not type_:
+                # TODO: fill in with brute force
+                continue
+            self.args[name].value = self._forgery_dict[type_]
+            self.args[name].method = "forged"
+            self.args[name].type_ = type_
+        for i, arg in enumerate(args):
+            self.args[i].value = arg
+            self.args[i].method = "specified"
+        for name, arg in kwargs.items():
+            self.args[name].value = arg
+            self.args[name].method = "specified"
+        return self.args
+
+    def _infer_types(self, brute_force=True):
+        """ Infer the argument types from the type annotations """
+        # TODO: modify state of self.args rather than calling in forge_args
+        type_dict = dict(self.spec.annotations)
+        type_dict = {k: v.__name__ for k, v in type_dict}
+        type_dict.pop("self", None)
+        return type_dict
+
+    def _brute_force_types(self):
+        # TODO: iterate through missing arguments, trying different things
+        # make a new class to do this?
+        pass
+

rp-0.1.1278/rp/libs/peepdis/datastructures.py

@@ -0,0 +1,147 @@
+from collections import OrderedDict
+from termcolor import colored
+from typing import Any, Callable, Dict, List, Tuple, Type, Union
+
+from peepdis.preferences import _PreferencesMixin
+
+
+class Arg(_PreferencesMixin):
+    def __init__(self, name, value: Any = None, type_: Type = None, method: str = None):
+        self.name = name
+        self.value = value
+        self.type_ = type_
+        self.method = method
+
+    def get_colored(self):
+        return colored(str(self), self._color_scheme[str(self.method)])
+
+    def __str__(self):
+        annotation_str = "="
+        if self._display_type_annotations:
+            annotation_str = f": {self.type_} = "
+        str_ = self.name + annotation_str + str(self.value)
+        return str_
+
+    def __eq__(self, other):
+        return self.value == other
+
+
+class ArgDict(OrderedDict, _PreferencesMixin):
+    def __init__(self, names: Union[Dict, List, Tuple]):
+        super().__init__()
+        if "self" in names:
+            names.remove("self")
+        if "return" in names:
+            names.remove("return")
+        if isinstance(names, dict):
+            for name, arg in names:
+                self[name] = Arg(name, arg)
+        else:
+            for name in names:
+                self[name] = Arg(name)
+        self.returns = None
+
+    def get_colored(self):
+        return [arg.get_colored() for arg in self.values()]
+
+    def update_positional(self, *args):
+        for i, arg in enumerate(args):
+            self[i].value = arg
+            self[i].method = "specified"
+
+    def update_kwargs(self, **kwargs):
+        for name, arg in kwargs:
+            self[name].value = arg
+            self[name].method = "specified"
+
+    def generate_args(self):
+        return {name: arg.value for name, arg in self.items()}
+
+    @property
+    def null_args(self):
+        nulls = tuple([k for k, v in self.items() if v.value is None])
+        return nulls
+
+    @property
+    def is_full(self):
+        if self.null_args:
+            return False
+        else:
+            return True
+
+    def __getitem__(self, key):
+        if isinstance(key, int):
+            key = list(self.keys())[key]
+        return super().__getitem__(key)
+
+    def __setitem__(self, key, value):
+        if not isinstance(value, Arg):
+            raise TypeError(f"`ArgDict` values must be type `Arg`, not: {type(value)}")
+        if isinstance(key, int):
+            key = list(self.keys())[key]
+        super().__setitem__(key, value)
+
+
+class Output(_PreferencesMixin):
+    _types = {float, int, list, dict, str, tuple}
+    _magics = {"__dict__", "__module__", "__weakref__", "__slotnames__"}
+    _builtins = {x for type_ in _types for x in dir(type_)} | _magics
+
+    def __init__(
+        self,
+        name: str,
+        value: Any,
+        args: ArgDict = None,
+        callable_: bool = False,
+        error: bool = False,
+        args_missing: bool = False,
+        unsupported_callable: bool = False,
+    ):
+        self.name = name
+        self.value = value
+        self.args = args if args else ArgDict([])
+        self.callable_ = callable_
+        self.error = error
+        self.args_missing = args_missing
+        self.unsupported_callable = unsupported_callable
+        self.builtin = True if name in self._builtins else False
+
+    def print(self):
+        print(*self.get_colored())
+
+    def get_colored(self):
+        # color name and arguments
+        base_color = self._color_scheme[self.obj_type]
+        base = colored(self.name, base_color)
+        if self.callable_:
+            open_parenthesis = colored("(", base_color)
+            close_parenthesis = colored(")", base_color)
+            args = colored(", ", base_color).join(self.args.get_colored())
+            base += open_parenthesis + args + close_parenthesis
+        colon = colored(":", base_color)
+        base += colon
+        # color output message
+        msg = colored(self.value, self._color_scheme[self.output_type])
+        return base, msg
+
+    @property
+    def obj_type(self):
+        if self.builtin:
+            return "builtin"
+        if self.callable_:
+            return "callable_"
+        else:
+            return "attr"
+
+    @property
+    def output_type(self):
+        if self.unsupported_callable:
+            return "null"
+        elif self.args_missing:
+            return "null"
+        elif self.error:
+            return "error"
+        elif self.builtin:
+            return "builtin"
+        else:
+            return "message"

rp-0.1.1278/rp/libs/peepdis/legacy.py

@@ -0,0 +1,157 @@
+from copy import deepcopy
+import re
+from termcolor import colored
+from types import (
+    BuiltinMethodType,
+    BuiltinFunctionType,
+    FunctionType,
+    MethodType,
+    ModuleType,
+)
+import sys
+
+
+def peep(obj, builtins=False, privates=False, docstrings=False,
+         truncate_len=250):
+    if not isinstance(obj, ModuleType):
+        obj = deepcopy(obj)
+    obj_dir = dir(obj)
+    output = OutputStrWrapper(truncate_len)
+    if builtins is False:
+        _is_magic = lambda x: (x.startswith("__") and x.endswith("__"))
+        obj_dir = [x for x in obj_dir if not _is_magic(x)]
+
+    if privates is False:
+        _is_private = lambda x: (x.startswith("_") and not x.endswith("_"))
+        obj_dir = [x for x in obj_dir if not _is_private(x)]
+
+    # check if debugging and define output function
+    gettrace = getattr(sys, "gettrace", None)
+    if gettrace():
+        debug = True
+    else:
+        debug = False
+
+    print(colored(getattr(obj, "__name__", ""), "red"))
+    doc = getattr(obj, "__doc__", "")
+    if callable(obj):
+        try:
+            print(obj())
+        except Exception as e:
+            if _positional_exception(e):
+                msg = "(requires positional arguments)"
+                msg_color = "grey"
+            else:
+                msg = f"RAISES EXCEPTION : {e}"
+                msg_color = "red"
+            output.add(
+                colored(f"{obj}(): ", "magenta"),
+                colored(msg, msg_color),
+                colored(doc, "green"),
+            )
+            print(colored(msg, "grey"))
+        print(colored(obj.__doc__, "green"))
+
+    for item in obj_dir:
+        attr = getattr(obj, item)
+        doc = ""
+        try:
+            if docstrings and attr.__doc__ is not None:
+                doc = "\n" + attr.__doc__
+            eval_str = str(attr)
+            eval_str = "" if eval_str == "None" else eval_str
+            if callable(attr) is False:
+                eval_str = _fix_if_multiline(eval_str)
+                output.add(
+                    colored(f"{item}: ", "cyan"),
+                    eval_str,
+                    colored(doc, "green")
+                )
+        except (Exception, BaseException) as e:
+            output.add(
+                colored(f"{item}: ", "cyan"),
+                colored(f"RAISES EXCEPTION : {e}", "red"),
+                colored(doc, "green"),
+            )
+            continue
+        if callable(attr):
+            try:
+                msg = str(attr())
+                msg = _fix_if_multiline(msg)
+                output.add(
+                    colored(f"{item}(): ", "magenta"),
+                    msg,
+                    colored(doc, "green")
+                )
+            except (Exception, BaseException) as e:
+                if _positional_exception(e):
+                    msg = "(requires positional arguments)"
+                    msg_color = "grey"
+                else:
+                    msg = f"RAISES EXCEPTION : {e}"
+                    msg_color = "red"
+                output.add(
+                    colored(f"{item}(): ", "magenta"),
+                    colored(msg, msg_color),
+                    colored(doc, "green"),
+                )
+                continue
+    return output
+
+
+class OutputStrWrapper:
+    def __init__(self, max_len):
+        self._max_len = max_len
+        self._output_str = ''
+
+    def add(self, *args):
+        str_ = _shorten(*args, max_len=self._max_len)
+        self._output_str += str_ + '\n'
+
+    def __repr__(self):
+        return str(self._output_str)
+
+    def __str__(self):
+        return repr(self)
+
+
+class Peeper:
+    def __init__(
+        self, obj, builtins=False, privates=False, docstrings=False, truncate_len=250
+    ):
+        pass
+
+
+def _shorten(*args, max_len):
+    str_ = "".join(args)
+    if max_len:
+        if len(str_) > max_len:
+            str_ = str_[:max_len] + " ..."
+    return str_
+
+
+def _fix_if_multiline(msg):
+    if "\n" in msg:
+        return "\n" + msg
+    else:
+        return msg
+
+
+def _positional_exception(e):
+    e = str(e).lower()
+    msgs = ('required argument', 'positional argument', 'missing argument',
+            'requires argument', 'must be given', 'takes exactly')
+    re_msgs = (r'exactly . argument', r'at least .* argument', )
+    if any([msg in e for msg in msgs]):
+        return True
+    if any([re.compile(msg).search(e) for msg in re_msgs]):
+        return True
+    else:
+        return False
+
+
+if __name__ == '__main__':
+    print(peep('asdf'))
+    import numpy as np
+    arr = np.array([1, 2, 3])
+    print(peep(arr))

rp-0.1.1278/rp/libs/peepdis/preferences.py

@@ -0,0 +1,22 @@
+class _PreferencesMixin:
+    _color_scheme = {
+        "error": "red",
+        "callable_": "cyan",
+        "attr": "magenta",
+        "message": "white",
+        "null": "grey",
+        "forged": "yellow",
+        "specified": "orange",
+        "default": "grey",
+        "None": "grey",
+        "builtin": "grey",
+    }
+    _display_type_annotations = True
+
+    @classmethod
+    def _load_preferences(cls):
+        pass
+
+    @classmethod
+    def _update_color_scheme(cls, key, value):
+        cls._color_scheme[key] = value

{rp-0.1.1277 → rp-0.1.1278}/rp/list_of_modules.py

@@ -12,6 +12,7 @@ rp.libs.jedi.plugins
 rp.libs.parso
 rp.libs.parso.pgen2
 rp.libs.parso.python
+rp.libs.peepdis
 rp.libs.pyflann
 rp.libs.pyflann.bindings
 rp.libs.pyflann.io

{rp-0.1.1277 → rp-0.1.1278}/rp/r.py

@@ -21735,14 +21735,12 @@ def pseudo_terminal(
 
                     elif user_message=='?e':
                         fansi_print("Running peepdis.peep(ans):","blue",'bold')
-                        pip_import('peepdis')
-                        from peepdis import peep
+                        from rp.libs.peepdis import peep
                         peep(get_ans())
                     elif user_message.endswith('?e') and not '\n' in user_message:
                         user_message=user_message[:-2]
                         fansi_print("running peepdis.peep(%s):"%user_message,"blue",'bold')
-                        pip_import('peepdis')
-                        from peepdis import peep
+                        from rp.libs.peepdis import peep
                         value=eval(user_message,scope())
                         peep(value)
                     elif user_message == "?":

{rp-0.1.1277 → rp-0.1.1278}/rp/rp_ptpython/key_bindings.py

@@ -71,8 +71,11 @@ def handle_run_cell(event):
     buffer=event.cli.current_buffer
     def main():
         text=buffer.document.text
+        shell_mode=text.startswith('!')
         cursor_pos=buffer.cursor_position
         cell_code=get_cell_code(text,cursor_pos,cell_boundary_prefix)
+        if shell_mode and not cell_code.startswith('!'):
+            cell_code='!'+cell_code
         from rp import fansi_print
         # fansi_print("RUNNING CODE CELL:",'blue','bold')
         # fansi_print(cell_code,'blue')
@@ -1294,6 +1297,32 @@ def handle_character(buffer,char,event=None):
         meta_pressed(clear=True)
         return True
 
+    if char=='`' and meta_pressed(clear=False):
+        #Toggle shell mode! Couldn't do alt+1 that's taken, so ` is nearby...
+
+        #Too fancy lol adding new lines etc...
+        # if text.startswith('!'):
+        #     text = text[1:]
+        #     lines = text.splitlines()
+        #     if not lines[0].strip():
+        #         del lines[0]
+        # else:
+        #     lines = text.splitlines()
+        #     if not lines[0].strip():
+        #         lines[0]='!'+lines[0]
+        #     else:
+        #         lines=['!']+lines
+        # text='\n'.join(lines)
+
+        if text.startswith('!'):
+            text=text[1:]
+        else:
+            text='!'+text
+
+        replace_buffer_text(buffer,text)
+        meta_pressed(clear=True)
+        return True
+
     if char=='\n' and before_line.lstrip().startswith('except ') and before_line.endswith(' as ') and after_line==':':
         #except Exception as |:      < \n >      ---->    except Exception:\n    |
         buffer.delete_before_cursor(len(' as '))

rp-0.1.1278/rp/version.py

@@ -0,0 +1 @@
+1278

{rp-0.1.1277 → rp-0.1.1278}/rp.egg-info/PKG-INFO

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