rp 0.1.1250__tar.gz → 0.1.1252__tar.gz

rp-0.1.1252/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 1.0
+Name: rp
+Version: 0.1.1252
+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.1252/rp/libs/draw_code_minimap.py

@@ -0,0 +1,159 @@
+import sys
+
+
+def draw_minimap(hscale: int, vscale: float, padding: int, code:str):
+    assert hscale >= 0, hscale
+    assert vscale >= 0, vscale
+    assert padding >= 0, padding
+
+    # We won't handle auto-importing this, as neither does black need to be...
+    # pip_import("drawille", auto_yes=True)
+
+    import drawille
+
+    # Prevent Giant Outputs
+    MIN_WIDTH = padding
+    MAX_WIDTH = 1000
+    MIN_HEIGHT = 1
+    MAX_HEIGHT = 100000
+
+    # Handle tabs as 4 spaces
+    code = code.replace("\t", "    ")
+
+    # Vertical Scaling
+    lines = code.splitlines()
+    num_lines = len(lines)
+    num_lines = max(MIN_HEIGHT, round(num_lines * vscale))
+    num_lines = min(num_lines, MAX_HEIGHT)
+    lines = resize_list(lines, num_lines)
+
+    # Horizontal Scaling
+    if isinstance(hscale, int):
+        lines = [line * hscale for line in lines]
+    else:
+        assert isinstance(hscale, float)
+        lines = [line[: int(MAX_WIDTH / hscale) + 1] for line in lines]
+        lines = [resize_list(line, round(len(line) * hscale)) for line in lines]
+        lines = ["".join(line) for line in lines]
+    lines = [line[:MAX_WIDTH] for line in lines]
+
+    HEIGHT = len(lines)
+    WIDTH = max(map(len, lines))
+    WIDTH = max(MIN_WIDTH, WIDTH)
+
+    canvas = drawille.Canvas()
+
+    # Set the size
+    canvas.set(0, 0)
+    canvas.set(WIDTH - 1, HEIGHT - 1)
+
+    for y, line in enumerate(lines):
+        for x, char in enumerate(line):
+            if char != " ":
+                canvas.set(x, y)
+
+    output = canvas.frame()
+    output = output.splitlines()
+    output = [x.ljust(MAX_WIDTH) for x in output]
+    output = '\n'.join(output)
+
+    print(output)
+    # print(make_string_rectangular(output).replace(" ", fansi("·", "green")))
+
+
+# INLINED FROM RP FOR FAST LOADING:
+
+
+def resize_list(array: list, length: int):
+    """
+    This function stretches or compresses a list to a given length using nearest-neighbor interpolation.
+    The last element of the input list is always included in the output list, regardless of the target length.
+
+    Parameters:
+        array (list): The input list to resize.
+        length (int): The target length of the list.
+
+    Assumptions:
+        The function assumes that the target length is a non-negative integer.
+
+    Returns:
+        list: The resized list to the target length.
+
+    Examples:
+        >>> resize_list([0,1,2,3,4], 5)
+        [0, 1, 2, 3, 4]
+        # The target length is the length of the input array. No change.
+
+        >>> resize_list([0,1,2,3,4,5,6,7,8,9], 5)
+        [0, 2, 4, 6, 9]
+        # Elements are skipped when resizing to a shorter length, but the last element is always included.
+
+        >>> resize_list([1,2,3,4,5,6,7,8,9], 3)
+        [1, 5, 9]
+
+        >>> resize_list([1,2,3,4,5,6,7,8,9], 5)
+        [1, 3, 5, 7, 9]
+
+        >>> resize_list([0,1,2,3,4], 10)
+        [0, 0, 1, 1, 2, 2, 3, 3, 4, 4]
+        # Elements are duplicated during resizing to a longer length.
+
+        >>> resize_list([0,1,2,3,4], 1)
+        [4]
+        # Even when resizing to length 1, the last element is included.
+
+        >>> resize_list(range(3000000000000000),4)
+        [0, 1000000000000000, 1999999999999999, 2999999999999999]
+        # Pro-tip: this ran in .00001 seconds! You can use it to get indices by passing in a range object
+
+    """
+
+    assert isinstance(
+        length, int
+    ), "Length must be an integer, but got %s instead" % repr(type(length))
+    assert length >= 0, (
+        "Length must be a non-negative integer, but got %i instead" % length
+    )
+
+    if len(array) > 1 and length > 1:
+        step = (len(array) - 1) / (length - 1)
+    else:
+        step = 0  # default step size to 0 if array has only 1 element or target length is 1
+
+    return [array[round(i * step)] for i in range(length)]
+
+
+def text_file_to_string(file_path: str) -> str:
+    "text_file_to_string(file_path) reads text file"
+
+    try:
+        return open(file_path).read()
+    except UnicodeDecodeError:
+        # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position 4781: ordinal not in range(128)
+        return open(file_path, encoding="latin").read()
+
+
+def usage():
+    print("Usage: %s <hscale> <vscale> <padding> [file]" % sys.argv[0], file=sys.stderr)
+
+
+def main():
+    if len(sys.argv) < 4:
+        usage()
+        sys.exit(1)
+
+    hscale = float(sys.argv[1])
+    vscale = float(sys.argv[2])
+    padding = int(sys.argv[3])
+
+    try:
+        file = sys.argv[4]
+        code = open(file).read()
+    except Exception:
+        code = sys.stdin.read()
+
+    draw_minimap(hscale, vscale, padding, code)
+
+
+if __name__ == "__main__":
+    main()

rp-0.1.1252/rp/libs/parso/__init__.py

@@ -0,0 +1,58 @@
+r"""
+Parso is a Python parser that supports error recovery and round-trip parsing
+for different Python versions (in multiple Python versions). Parso is also able
+to list multiple syntax errors in your python file.
+
+Parso has been battle-tested by jedi_. It was pulled out of jedi to be useful
+for other projects as well.
+
+Parso consists of a small API to parse Python and analyse the syntax tree.
+
+.. _jedi: https://github.com/davidhalter/jedi
+
+A simple example:
+
+>>> import rp.libs.parso
+>>> module = parso.parse('hello + 1', version="3.6")
+>>> expr = module.children[0]
+>>> expr
+PythonNode(arith_expr, [<Name: hello@1,0>, <Operator: +>, <Number: 1>])
+>>> print(expr.get_code())
+hello + 1
+>>> name = expr.children[0]
+>>> name
+<Name: hello@1,0>
+>>> name.end_pos
+(1, 5)
+>>> expr.end_pos
+(1, 9)
+
+To list multiple issues:
+
+>>> grammar = parso.load_grammar()
+>>> module = grammar.parse('foo +\nbar\ncontinue')
+>>> error1, error2 = grammar.iter_errors(module)
+>>> error1.message
+'SyntaxError: invalid syntax'
+>>> error2.message
+"SyntaxError: 'continue' not properly in loop"
+"""
+
+from rp.libs.parso.parser import ParserSyntaxError
+from rp.libs.parso.grammar import Grammar, load_grammar
+from rp.libs.parso.utils import split_lines, python_bytes_to_unicode
+
+
+__version__ = '0.5.1'
+
+
+def parse(code=None, **kwargs):
+    """
+    A utility function to avoid loading grammars.
+    Params are documented in :py:meth:`parso.Grammar.parse`.
+
+    :param str version: The version used by :py:func:`parso.load_grammar`.
+    """
+    version = kwargs.pop('version', None)
+    grammar = load_grammar(version=version)
+    return grammar.parse(code, **kwargs)

rp-0.1.1252/rp/libs/parso/_compatibility.py

@@ -0,0 +1,103 @@
+"""
+To ensure compatibility from Python ``2.6`` - ``3.3``, a module has been
+created. Clearly there is huge need to use conforming syntax.
+"""
+import sys
+import platform
+
+# Cannot use sys.version.major and minor names, because in Python 2.6 it's not
+# a namedtuple.
+py_version = int(str(sys.version_info[0]) + str(sys.version_info[1]))
+
+# unicode function
+try:
+    unicode = unicode
+except NameError:
+    unicode = str
+
+is_pypy = platform.python_implementation() == 'PyPy'
+
+
+def use_metaclass(meta, *bases):
+    """ Create a class with a metaclass. """
+    if not bases:
+        bases = (object,)
+    return meta("HackClass", bases, {})
+
+
+try:
+    encoding = sys.stdout.encoding
+    if encoding is None:
+        encoding = 'utf-8'
+except AttributeError:
+    encoding = 'ascii'
+
+
+def u(string):
+    """Cast to unicode DAMMIT!
+    Written because Python2 repr always implicitly casts to a string, so we
+    have to cast back to a unicode (and we know that we always deal with valid
+    unicode, because we check that in the beginning).
+    """
+    if py_version >= 30:
+        return str(string)
+
+    if not isinstance(string, unicode):
+        return unicode(str(string), 'UTF-8')
+    return string
+
+
+try:
+    FileNotFoundError = FileNotFoundError
+except NameError:
+    FileNotFoundError = IOError
+
+
+def utf8_repr(func):
+    """
+    ``__repr__`` methods in Python 2 don't allow unicode objects to be
+    returned. Therefore cast them to utf-8 bytes in this decorator.
+    """
+    def wrapper(self):
+        result = func(self)
+        if isinstance(result, unicode):
+            return result.encode('utf-8')
+        else:
+            return result
+
+    if py_version >= 30:
+        return func
+    else:
+        return wrapper
+
+
+try:
+    from functools import total_ordering
+except ImportError:
+    # Python 2.6
+    def total_ordering(cls):
+        """Class decorator that fills in missing ordering methods"""
+        convert = {
+            '__lt__': [('__gt__', lambda self, other: not (self < other or self == other)),
+                       ('__le__', lambda self, other: self < other or self == other),
+                       ('__ge__', lambda self, other: not self < other)],
+            '__le__': [('__ge__', lambda self, other: not self <= other or self == other),
+                       ('__lt__', lambda self, other: self <= other and not self == other),
+                       ('__gt__', lambda self, other: not self <= other)],
+            '__gt__': [('__lt__', lambda self, other: not (self > other or self == other)),
+                       ('__ge__', lambda self, other: self > other or self == other),
+                       ('__le__', lambda self, other: not self > other)],
+            '__ge__': [('__le__', lambda self, other: (not self >= other) or self == other),
+                       ('__gt__', lambda self, other: self >= other and not self == other),
+                       ('__lt__', lambda self, other: not self >= other)]
+        }
+        roots = set(dir(cls)) & set(convert)
+        if not roots:
+            raise ValueError('must define at least one ordering operation: < > <= >=')
+        root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
+        for opname, opfunc in convert[root]:
+            if opname not in roots:
+                opfunc.__name__ = opname
+                opfunc.__doc__ = getattr(int, opname).__doc__
+                setattr(cls, opname, opfunc)
+        return cls