pyscript-programming-language 1.7.2__tar.gz → 1.7.3__tar.gz

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.7.3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.7.2
+Version: 1.7.3
 Summary: PyScript Programming Language
-Home-page: https://github.com/azzammuhyala/pyscript
+Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala
 Author-email: azzammuhyala@gmail.com
 License: MIT

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.7.3}/pyscript/__main__.py

@@ -9,7 +9,8 @@ from .core.version import __version__
 
 from argparse import ArgumentParser
 from os import environ
-from sys import executable, stderr, version_info, exit, setrecursionlimit
+
+import sys
 
 FORMAT_HIGHLIGHT_MAP = {
     'html': HLFMT_HTML,
@@ -18,8 +19,8 @@ FORMAT_HIGHLIGHT_MAP = {
 }
 
 parser = ArgumentParser(
-    prog=f'{get_module_name_from_path(executable)} -m pyscript',
-    description=f'PyScript Launcher for Python Version {".".join(map(str, version_info))}'
+    prog=f'{get_module_name_from_path(sys.executable)} -m pyscript',
+    description=f'PyScript Launcher for Python Version {".".join(map(str, sys.version_info))}'
 )
 
 parser.add_argument(
@@ -27,7 +28,7 @@ parser.add_argument(
     type=str,
     nargs='?',
     default=None,
-    help="file path"
+    help="File path to be executed"
 )
 
 parser.add_argument(
@@ -40,53 +41,53 @@ parser.add_argument(
     '-c', '--command',
     type=str,
     default=None,
-    help="execute PyScript from argument",
+    help="Execute program from a string argument",
 )
 
 parser.add_argument(
     '-d', '--debug',
     action='store_true',
-    help="set a debug flag, this will remove the assert statement"
+    help="Set a debug flag, this will remove the assert statement"
 )
 
 parser.add_argument(
     '-i', '--inspect',
     action='store_true',
-    help="inspect interactively after running a file",
+    help="Inspect interactively after running a 'file'",
 )
 
 parser.add_argument(
     '-l', '--highlight',
     choices=tuple(FORMAT_HIGHLIGHT_MAP.keys()),
     default=None,
-    help='generate PyScript highlight code from a file'
+    help="Generate highlight code from a 'file'"
 )
 
 parser.add_argument(
     '-n', '--no-color',
     action='store_true',
-    help="no colorful traceback"
+    help="Suppress colored output"
 )
 
 parser.add_argument(
     '-r', '--py-recursion',
     type=int,
     default=None,
-    help="set a python recursion limit"
+    help="Set a Python recursion limit"
 )
 
 def argument_error(argument, message):
-    parser.print_usage(stderr)
+    parser.print_usage(sys.stderr)
     parser.exit(2, f"{parser.prog}: error: argument {argument}: {message}\n")
 
 args = parser.parse_args()
 
 if args.highlight and args.file is None:
-    argument_error("-l/--highlight", "file path require")
+    argument_error("-l/--highlight", "argument 'file' required")
 
 if args.py_recursion is not None:
     try:
-        setrecursionlimit(args.py_recursion)
+        sys.setrecursionlimit(args.py_recursion)
     except BaseException as e:
         argument_error("-r/--py-recursion", e)
 
@@ -121,7 +122,7 @@ if args.file is not None:
 
     if args.highlight:
         try:
-            print(pys_highlight(file, FORMAT_HIGHLIGHT_MAP.get(args.highlight, None)))
+            print(pys_highlight(file, FORMAT_HIGHLIGHT_MAP.get(args.highlight)))
         except BaseException as e:
             parser.error(f"file {path!r}: Highlight error: {e}")
 
@@ -150,4 +151,4 @@ elif args.command is not None:
 else:
     code = pys_shell(undefined, flags)
 
-exit(code)
+sys.exit(code)

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.7.3}/pyscript/core/analyzer.py

@@ -157,23 +157,25 @@ class PysAnalyzer(Pys):
         self.visit(node.right)
 
     def visit_UnaryOperatorNode(self, node):
+        value = node.value
+
         if is_incremental(node.operand.type):
-            type = node.value.__class__
+            type = value.__class__
             operator = 'increase' if node.operand.type == TOKENS['DOUBLE-PLUS'] else 'decrease'
 
             if type is PysKeywordNode:
-                self.throw(f"cannot {operator} {node.value.token.value}", node.value.position)
+                self.throw(f"cannot {operator} {value.name.value}", value.position)
                 return
 
-            elif isinstance(node.value, PysNode):
+            elif isinstance(value, PysNode):
                 if type not in (PysIdentifierNode, PysAttributeNode, PysSubscriptNode):
-                    self.throw(f"cannot {operator} literal", node.value.position)
+                    self.throw(f"cannot {operator} literal", value.position)
                     return
 
             else:
                 raise TypeError("UnaryOperator: node.value is not PysNode")
 
-        self.visit(node.value)
+        self.visit(value)
 
     def visit_StatementsNode(self, node):
         for element in node.body:
@@ -435,7 +437,7 @@ class PysAnalyzer(Pys):
                     return
 
             elif type is PysKeywordNode:
-                self.throw(f"cannot delete {target.token.value}", target.position)
+                self.throw(f"cannot delete {target.name.value}", target.position)
                 return
 
             elif isinstance(target, PysNode):
@@ -502,7 +504,7 @@ class PysAnalyzer(Pys):
                     return
 
         elif type is PysKeywordNode:
-            self.throw(f"cannot assign to {node.token.value}", node.position)
+            self.throw(f"cannot assign to {node.name.value}", node.position)
 
         elif isinstance(node, PysNode):
             if type is not PysIdentifierNode:

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.7.3}/pyscript/core/exceptions.py

@@ -21,6 +21,8 @@ class PysTraceback(Pys):
         return f'<traceback of exception {self.exception!r}>'
 
     def string_traceback(self):
+        from .position import format_arrow  # circular import problem solved
+
         context = self.context
         position = self.position
 
@@ -44,7 +46,7 @@ class PysTraceback(Pys):
                 '{}{}{}'.format(
                     '' if is_positionless else f', line {magenta}{position.start_line}{reset}',
                     '' if context_name is None else f', in {magenta}{context_name}{reset}',
-                    '' if is_positionless else f'\n{indent(position.format_arrow(colored), 4)}'
+                    '' if is_positionless else f'\n{indent(format_arrow(position, colored), 4)}'
                 )
             )
 

pyscript_programming_language-1.7.3/pyscript/core/mapping.py

@@ -0,0 +1,131 @@
+from .constants import TOKENS, KEYWORDS
+
+from operator import (
+    is_not, eq, ne, lt, gt, le, ge, add, sub, mul, truediv, floordiv, pow, matmul, mod, and_, or_, xor, lshift, rshift,
+    iadd, isub, imul, itruediv, ifloordiv, ipow, imatmul, imod, iand, ior, ixor, ilshift, irshift, pos, neg, inv
+)
+from types import MappingProxyType
+
+BINARY_FUNCTIONS_MAP = MappingProxyType({
+    TOKENS['NOT-IN']: lambda a, b : a not in b,
+    TOKENS['IS-NOT']: is_not,
+    TOKENS['PLUS']: add,
+    TOKENS['MINUS']: sub,
+    TOKENS['STAR']: mul,
+    TOKENS['SLASH']: truediv,
+    TOKENS['DOUBLE-SLASH']: floordiv,
+    TOKENS['DOUBLE-STAR']: pow,
+    TOKENS['AT']: matmul,
+    TOKENS['PERCENT']: mod,
+    TOKENS['AMPERSAND']: and_,
+    TOKENS['PIPE']: or_,
+    TOKENS['CIRCUMFLEX']: xor,
+    TOKENS['DOUBLE-LESS-THAN']: lshift,
+    TOKENS['DOUBLE-GREATER-THAN']: rshift,
+    TOKENS['DOUBLE-EQUAL']: eq,
+    TOKENS['EQUAL-EXCLAMATION']: ne,
+    TOKENS['LESS-THAN']: lt,
+    TOKENS['GREATER-THAN']: gt,
+    TOKENS['EQUAL-LESS-THAN']: le,
+    TOKENS['EQUAL-GREATER-THAN']: ge,
+    TOKENS['EQUAL-PLUS']: iadd,
+    TOKENS['EQUAL-MINUS']: isub,
+    TOKENS['EQUAL-STAR']: imul,
+    TOKENS['EQUAL-SLASH']: itruediv,
+    TOKENS['EQUAL-DOUBLE-SLASH']: ifloordiv,
+    TOKENS['EQUAL-DOUBLE-STAR']: ipow,
+    TOKENS['EQUAL-AT']: imatmul,
+    TOKENS['EQUAL-PERCENT']: imod,
+    TOKENS['EQUAL-AMPERSAND']: iand,
+    TOKENS['EQUAL-PIPE']: ior,
+    TOKENS['EQUAL-CIRCUMFLEX']: ixor,
+    TOKENS['EQUAL-DOUBLE-LESS-THAN']: ilshift,
+    TOKENS['EQUAL-DOUBLE-GREATER-THAN']: irshift,
+})
+
+UNARY_FUNCTIONS_MAP = MappingProxyType({
+    TOKENS['PLUS']: pos,
+    TOKENS['MINUS']: neg,
+    TOKENS['TILDE']: inv
+})
+
+KEYWORDS_TO_VALUES_MAP = MappingProxyType({
+    KEYWORDS['True']: True,
+    KEYWORDS['False']: False,
+    KEYWORDS['None']: None,
+    KEYWORDS['true']: True,
+    KEYWORDS['false']: False,
+    KEYWORDS['none']: None
+})
+
+BRACKETS_MAP = MappingProxyType({
+    TOKENS['LEFT-PARENTHESIS']: TOKENS['RIGHT-PARENTHESIS'],
+    TOKENS['LEFT-SQUARE']: TOKENS['RIGHT-SQUARE'],
+    TOKENS['LEFT-CURLY']: TOKENS['RIGHT-CURLY']
+})
+
+SYMBOLS_TOKEN_MAP = MappingProxyType({
+    TOKENS['NOT-IN']: KEYWORDS['not'] + ' ' + KEYWORDS['in'],
+    TOKENS['IS-NOT']: KEYWORDS['is'] + ' ' + KEYWORDS['not'],
+    TOKENS['NULL']: '\0',
+    TOKENS['NEWLINE']: '\n',
+    TOKENS['EXCLAMATION']: '!',
+    TOKENS['COMMENT']: '#',
+    TOKENS['PERCENT']: '%',
+    TOKENS['AMPERSAND']: '&',
+    TOKENS['RIGHT-PARENTHESIS']: ')',
+    TOKENS['LEFT-PARENTHESIS']: '(',
+    TOKENS['STAR']: '*',
+    TOKENS['PLUS']: '+',
+    TOKENS['COMMA']: ',',
+    TOKENS['MINUS']: '-',
+    TOKENS['DOT']: '.',
+    TOKENS['SLASH']: '/',
+    TOKENS['COLON']: ':',
+    TOKENS['SEMICOLON']: ';',
+    TOKENS['LESS-THAN']: '<',
+    TOKENS['EQUAL']: '=',
+    TOKENS['GREATER-THAN']: '>',
+    TOKENS['QUESTION']: '?',
+    TOKENS['AT']: '@',
+    TOKENS['LEFT-SQUARE']: '[',
+    TOKENS['RIGHT-SQUARE']: ']',
+    TOKENS['CIRCUMFLEX']: '^',
+    TOKENS['LEFT-CURLY']: '{',
+    TOKENS['PIPE']: '|',
+    TOKENS['RIGHT-CURLY']: '}',
+    TOKENS['TILDE']: '~',
+    TOKENS['DOUBLE-AMPERSAND']: '&&',
+    TOKENS['DOUBLE-STAR']: '**',
+    TOKENS['DOUBLE-PLUS']: '++',
+    TOKENS['DOUBLE-MINUS']: '--',
+    TOKENS['DOUBLE-SLASH']: '//',
+    TOKENS['DOUBLE-LESS-THAN']: '<<',
+    TOKENS['DOUBLE-EQUAL']: '==',
+    TOKENS['DOUBLE-GREATER-THAN']: '>>',
+    TOKENS['DOUBLE-QUESTION']: '??',
+    TOKENS['DOUBLE-PIPE']: '||',
+    TOKENS['TRIPLE-DOT']: '...',
+    TOKENS['EQUAL-EXCLAMATION']: '!=',
+    TOKENS['EQUAL-PERCENT']: '%=',
+    TOKENS['EQUAL-AMPERSAND']: '&=',
+    TOKENS['EQUAL-STAR']: '*=',
+    TOKENS['EQUAL-PLUS']: '+=',
+    TOKENS['EQUAL-MINUS']: '-=',
+    TOKENS['EQUAL-SLASH']: '/=',
+    TOKENS['EQUAL-COLON']: ':=',
+    TOKENS['EQUAL-LESS-THAN']: '<=',
+    TOKENS['EQUAL-GREATER-THAN']: '>=',
+    TOKENS['EQUAL-AT']: '@=',
+    TOKENS['EQUAL-CIRCUMFLEX']: '^=',
+    TOKENS['EQUAL-PIPE']: '|=',
+    TOKENS['EQUAL-TILDE']: '~=',
+    TOKENS['EQUAL-DOUBLE-STAR']: '**=',
+    TOKENS['EQUAL-DOUBLE-SLASH']: '//=',
+    TOKENS['EQUAL-DOUBLE-LESS-THAN']: '<<=',
+    TOKENS['EQUAL-DOUBLE-GREATER-THAN']: '>>=',
+    TOKENS['EQUAL-ARROW']: '=>',
+    TOKENS['EXCLAMATION-TILDE']: '~!'
+})
+
+EMPTY_MAP = MappingProxyType({})

{pyscript_programming_language-1.7.2 → pyscript_programming_language-1.7.3}/pyscript/core/objects.py

@@ -19,10 +19,11 @@ class PysCode(PysObject):
 class PysPythonFunction(PysObject):
 
     def __init__(self, func):
-        from .handlers import handle_call
+        from .handlers import handle_call  # circular import problem solved
 
-        self.__name__ = func.__name__
-        self.__qualname__ = func.__qualname__
+        self.__name__ = getattr(func, '__name__', '<function>')
+        self.__qualname__ = getattr(func, '__qualname__', '<function>')
+        self.__doc__ = getattr(func, '__doc__', None)
         self.__func__ = func
         self.__code__ = PysCode(
             position=None,
@@ -46,7 +47,7 @@ class PysPythonFunction(PysObject):
 class PysFunction(PysObject):
 
     def __init__(self, name, qualname, parameters, body, position, context):
-        from .interpreter import visit
+        from .interpreter import visit  # circular import problem solved
 
         context = context.parent if isinstance(context, PysClassContext) else context
 

pyscript_programming_language-1.7.3/pyscript/core/position.py

@@ -0,0 +1,99 @@
+from .bases import Pys
+from .buffer import PysFileBuffer
+from .utils.ansi import BOLD, acolor
+from .utils.decorators import typechecked, immutable
+from .utils.generic import setimuattr
+
+@immutable
+class PysPosition(Pys):
+
+    __slots__ = ('file', 'start', 'end', 'start_line', 'start_column', 'end_line', 'end_column', 'is_positionless')
+
+    @typechecked
+    def __init__(self, file: PysFileBuffer, start: int, end: int) -> None:
+        is_positionless = start < 0 or end < 0 or start > end or end > len(file.text) + 1
+
+        setimuattr(self, 'file', file)
+        setimuattr(self, 'start', -1 if is_positionless else start)
+        setimuattr(self, 'end', -1 if is_positionless else end)
+        setimuattr(self, 'start_line', -1 if is_positionless else file.text.count('\n', 0, start) + 1)
+        setimuattr(self, 'start_column', -1 if is_positionless else start - file.text.rfind('\n', 0, start))
+        setimuattr(self, 'end_line', -1 if is_positionless else file.text.count('\n', 0, end) + 1)
+        setimuattr(self, 'end_column', -1 if is_positionless else end - file.text.rfind('\n', 0, end))
+        setimuattr(self, 'is_positionless', is_positionless)
+
+    def __repr__(self):
+        return f'<Position({self.start!r}, {self.end!r}) from {self.file.name!r}>'
+
+def format_arrow(position, colored=True):
+    if position.is_positionless:
+        return ''
+
+    if colored:
+        reset = acolor('reset')
+        bred = acolor('red', style=BOLD)
+    else:
+        reset = ''
+        bred = ''
+
+    line_start = position.start_line
+    line_end = position.end_line
+    column_start = position.start_column
+    column_end = position.end_column
+
+    text = position.file.text
+
+    start = text.rfind('\n', 0, position.start) + 1
+    end = text.find('\n', start + 1)
+    if end == -1:
+        end = len(text)
+
+    if text[position.start:position.end] in ('', '\n'):
+        if position.start > start:
+            line = text[start:end].lstrip().replace('\t', ' ')
+            return f'{line}\n{bred}{" " * len(line)}^{reset}'
+        return f'\n{bred}^{reset}'
+
+    result = []
+    lines = []
+    count = line_end - line_start + 1
+
+    for i in range(count):
+        line = text[start:end].lstrip('\n')
+
+        lines.append(
+            (
+                line,
+                len(line.lstrip()),
+                column_start - 1 if i == 0 else 0,
+                column_end - 1 if i == count - 1 else len(line)
+            )
+        )
+
+        start = end
+        end = text.find('\n', start + 1)
+        if end == -1:
+            end = len(text)
+
+    minimum_indent = min(len(line) - line_code_length for line, line_code_length, _, _ in lines)
+
+    for i, (line, line_code_length, start, end) in enumerate(lines):
+        line = line[minimum_indent:]
+        er = end - minimum_indent
+
+        if i == 0:
+            sr = start - minimum_indent
+
+            arrow = '^' * (end - start)
+            line = f'{line[:sr]}{bred}{line[sr:er]}{reset}{line[er:]}\n{" " * sr}{bred}{arrow}{reset}'
+
+        else:
+            indent = len(line) - line_code_length
+
+            arrow = '^' * (end - start - (minimum_indent + indent))
+            line = f'{line[:indent]}{bred}{line[indent:er]}{reset}{line[er:]}\n{" " * indent}{bred}{arrow}{reset}'
+
+        if arrow:
+            result.append(line)
+
+    return '\n'.join(result).replace('\t', ' ')