pyscript-programming-language 1.11.1__tar.gz → 1.11.2__tar.gz

pyscript_programming_language-1.11.2/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+
+recursive-include pyscript *
+recursive-exclude backup *

{pyscript_programming_language-1.11.1/pyscript_programming_language.egg-info → pyscript_programming_language-1.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyscript-programming-language
-Version: 1.11.1
+Version: 1.11.2
 Summary: PyScript Programming Language
 Home-page: https://azzammuhyala.github.io/pyscript
 Author: azzammuhyala

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/__main__.py

@@ -7,17 +7,15 @@ from .core.highlight import (
     HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptStyle, PygmentsPyScriptLexer
 )
 from .core.runner import _normalize_namespace, pys_runner, pys_shell
-from .core.utils.module import get_module_name_from_path, remove_python_path
-from .core.utils.path import normpath, getcwd
+from .core.utils.module import remove_python_path
+from .core.utils.path import getcwd, normpath, get_name_from_path
 from .core.version import __version__
 
 try:
     from pygments import highlight
     from pygments.formatters import (
-        BBCodeFormatter,
-        HtmlFormatter,
-        LatexFormatter,
-        TerminalFormatter, TerminalTrueColorFormatter, Terminal256Formatter
+        BBCodeFormatter, HtmlFormatter, LatexFormatter, TerminalFormatter, TerminalTrueColorFormatter,
+        Terminal256Formatter
     )
 
     FORMAT_PYGMENTS_MAP = {
@@ -45,7 +43,7 @@ FORMAT_HIGHLIGHT_MAP = {
 }
 
 parser = ArgumentParser(
-    prog=f'{get_module_name_from_path(sys.executable)} -m pyscript',
+    prog=f'{get_name_from_path(sys.executable)} -m pyscript',
     description=f'PyScript Launcher for Python Version {".".join(map(str, sys.version_info))}'
 )
 
@@ -70,7 +68,7 @@ parser.add_argument(
 
 parser.add_argument(
     '-e', '--editor',
-    choices=('terminal', 'gui'),
+    choices=('gui', 'terminal'),
     default=None,
     help="Open the editor panel from a 'file'",
 )
@@ -187,10 +185,10 @@ if args.file is not None:
 
     if args.editor:
         try:
-            if args.editor == 'terminal':
-                editor = PysTerminalEditor
-            elif args.editor == 'gui':
+            if args.editor == 'gui':
                 editor = PysGUIEditor
+            elif args.editor == 'terminal':
+                editor = PysTerminalEditor
             editor(file).run()
         except BaseException as e:
             argument_error('-e/--editor', e)
@@ -228,6 +226,7 @@ if args.file is not None:
         if args.inspect and not (sys.stdout.closed or sys.stderr.closed):
             if sys.stdin.closed:
                 print("Can't run interactive shell: sys.stdin closed", file=sys.stderr)
+                code = 1
             else:
                 code = pys_shell(
                     globals=result.context.symbol_table,

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/analyzer.py

@@ -1,5 +1,5 @@
 from .bases import Pys
-from .checks import is_unpack_assignment
+from .checks import is_list
 from .constants import TOKENS, DEFAULT
 from .context import PysContext
 from .exceptions import PysTraceback
@@ -516,7 +516,7 @@ class PysAnalyzer(Pys):
 
             self.visit_slice_SubscriptNode(node.slice)
 
-        elif is_unpack_assignment(type):
+        elif is_list(type):
             for element in node.elements:
                 self.visit_declaration_AssignNode(element, message, operator_name)
                 if self.error:

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/cache.py

@@ -7,8 +7,8 @@ from .utils.decorators import inheritable, singleton
 from typing import Any, Callable, Literal
 
 loading_modules = set()
-modules = {}
 path = [SITE_PACKAGES_PATH, LIBRARIES_PATH]
+modules = {}
 singletons = {}
 
 @singleton

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/checks.py

@@ -14,7 +14,7 @@ is_statement = frozenset([
     PysAssertNode, PysDeleteNode, PysContinueNode, PysBreakNode
 ]).__contains__
 
-is_unpack_assignment = frozenset([
+is_list = frozenset([
     PysSetNode, PysListNode, PysTupleNode
 ]).__contains__
 

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/constants.py

@@ -14,6 +14,7 @@ ENV_PYSCRIPT_NO_EXCEPTHOOK = 'PYSCRIPT_NO_EXCEPTHOOK'
 ENV_PYSCRIPT_NO_GIL = 'PYSCRIPT_NO_GIL'
 ENV_PYSCRIPT_NO_READLINE = 'PYSCRIPT_NO_READLINE'
 ENV_PYSCRIPT_NO_TYPECHECK = 'PYSCRIPT_NO_TYPECHECK'
+ENV_PYSCRIPT_MAXIMUM_TRACEBACK_LINE = 'PYSCRIPT_MAXIMUM_TRACEBACK_LINE'
 
 # tokens offset
 DOUBLE = 2**8
@@ -96,9 +97,10 @@ TOKENS = MappingProxyType({
 # keywords
 KEYWORDS = (
     '__debug__', 'False', 'None', 'True', 'and', 'as', 'assert', 'break', 'case', 'catch', 'class', 'constructor',
-    'continue', 'def', 'default', 'define', 'del', 'delete', 'do', 'elif', 'else', 'except', 'extends', 'false',
-    'finally', 'for', 'from', 'func', 'function', 'global', 'if', 'import', 'in', 'is', 'match', 'nil', 'none', 'null',
-    'not', 'true', 'typeof', 'of', 'or', 'raise', 'repeat', 'return', 'switch', 'throw', 'try', 'until', 'while', 'with'
+    'continue', 'def', 'default', 'define', 'del', 'delete', 'do', 'elif', 'else', 'elseif', 'except', 'extends',
+    'false', 'finally', 'for', 'from', 'func', 'function', 'global', 'if', 'import', 'in', 'is', 'match', 'nil', 'none',
+    'null', 'not', 'true', 'typeof', 'of', 'or', 'raise', 'repeat', 'return', 'switch', 'throw', 'try', 'until',
+    'while', 'with'
 )
 
 CONSTANT_KEYWORDS = (

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/editor/bases.py

@@ -28,7 +28,7 @@ class PysEditor(Pys):
             setimuattr(self.file, 'text', text)
         self.modified = False
 
-    def run(self):
+    def run(self) -> None:
         if self.used:
             raise RuntimeError("one application object can only be used once")
         self.used = True

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/editor/gui.py

@@ -1,12 +1,10 @@
 from .bases import PysEditor
 from ..buffer import PysFileBuffer
+from ..constants import ICON_PATH
+from ..highlight import PygmentsPyScriptStyle, PygmentsPyScriptLexer
+from ..version import __version__
 
 try:
-
-    from ..constants import ICON_PATH
-    from ..highlight import PygmentsPyScriptStyle, PygmentsPyScriptLexer
-    from ..version import __version__
-
     from tkinter import END, Tk, Scrollbar, Text, messagebox
     from tkinter.font import Font
 
@@ -63,6 +61,10 @@ try:
             self.setup_tags()
             self.update()
 
+        def run(self) -> None:
+            PysEditor.run(self)
+            Tk.mainloop(self)
+
         def setup_tags(self):
             tag_configure = self.text.tag_configure
             for token, style in self.style.list_styles():
@@ -125,10 +127,6 @@ try:
             self.text.configure(wrap='char' if self.wrapped else 'none')
             return 'break'
 
-        def run(self):
-            PysEditor.run(self)
-            Tk.mainloop(self)
-
 except ImportError as e:
     _error = e
 

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/editor/terminal.py

@@ -1,11 +1,9 @@
 from .bases import PysEditor
 from ..buffer import PysFileBuffer
+from ..highlight import PygmentsPyScriptStyle, PygmentsPyScriptLexer
+from ..version import __version__
 
 try:
-
-    from ..highlight import PygmentsPyScriptStyle, PygmentsPyScriptLexer
-    from ..version import __version__
-
     from prompt_toolkit.application import Application
     from prompt_toolkit.filters import Condition
     from prompt_toolkit.formatted_text import ANSI
@@ -65,6 +63,10 @@ try:
             def _(event):
                 self.wrapped = not self.wrapped
 
+            @self.key_bindings.add('c-z', filter=on_edit, eager=True)
+            def _(event):
+                self.current_buffer.undo()
+
             @self.key_bindings.add('c-s', filter=on_edit, eager=True)
             def _(event):
                 self.save(self.text.text)
@@ -119,20 +121,24 @@ try:
                 style=style_from_pygments_cls(PygmentsPyScriptStyle),
                 key_bindings=self.key_bindings,
                 full_screen=True,
-                mouse_support=True
+                mouse_support=True,
+                paste_mode=True
             )
 
+        def run(self) -> None:
+            PysEditor.run(self)
+            Application.run(self)
+
         def on_change(self, buffer):
             self.modified = True
 
         def create_title(self):
-            title = f'  PyScript {__version__} - {self.basename}{"*" if self.modified else ""}  '
-            space = max(0, self.output.get_size().columns - len(title))
-            return ANSI(f'\x1b[7m{title}{" " * space}\x1b[0m')
-
-        def run(self):
-            PysEditor.run(self)
-            Application.run(self)
+            columns = self.output.get_size().columns
+            file = f'{self.basename}{"*" if self.modified else ""}'
+            title = f'  PyScript {__version__} - {file}  '
+            if len(title) > columns:
+                title = file
+            return ANSI(f'\x1b[7m{title}{" " * max(0, columns - len(title))}\x1b[0m')
 
 except ImportError as e:
     _error = e

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/handlers.py

@@ -6,6 +6,7 @@ from types import MethodType
 
 if environ.get(ENV_PYSCRIPT_NO_GIL) is None:
     from threading import RLock
+
     lock = RLock()
 
     def handle_call(object, context, position):
@@ -28,7 +29,7 @@ if environ.get(ENV_PYSCRIPT_NO_GIL) is None:
                 if method is not None:
                     handle_call(method, context, position)
 
-    _GIL = True
+    GIL = True
 else:
 
     def handle_call(object, context, position):
@@ -49,4 +50,4 @@ else:
             if method is not None:
                 handle_call(method, context, position)
 
-    _GIL = False
+    GIL = False

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/highlight.py

@@ -373,21 +373,21 @@ class _PysHighlightFormatter(Pys):
         self._open = False
 
     def __call__(self, type: str, position: PysPosition, content: str) -> str:
-        result = ''
-
         if type == 'end':
             if self._open:
-                result += self.close_block(position, self._type)
+                result = self.close_block(position, self._type)
                 self._open = False
+            else:
+                result = ''
             type = 'start'
 
         elif type == self._type and self._open:
-            result += self.content_block(position, content)
+            result = self.content_block(position, content)
 
         else:
+            result = ''
             if self._open:
                 result += self.close_block(position, self._type)
-
             result += self.open_block(position, type) + self.content_block(position, content)
             self._open = True
 
@@ -450,10 +450,10 @@ def pys_highlight(
     )
 
     tokens, _ = lexer.make_tokens()
-
     text = file.text
+
     result = ''
-    last_index_position = 0
+    last_index = 0
     brackets_stack = []
 
     for i, token in enumerate(tokens):
@@ -461,66 +461,66 @@ def pys_highlight(
         tvalue = token.value
 
         if ttype == TOKENS['NULL']:
-            type_fmt = 'end'
+            type_format = 'end'
 
         elif ttype == TOKENS['KEYWORD']:
-            type_fmt = 'keyword-constant' if is_constant_keywords(tvalue) else 'keyword'
+            type_format = 'keyword-constant' if is_constant_keywords(tvalue) else 'keyword'
 
         elif ttype == TOKENS['IDENTIFIER']:
             if tvalue in BUILTIN_TYPES:
-                type_fmt = 'identifier-type'
+                type_format = 'identifier-type'
             elif tvalue in BUILTIN_FUNCTIONS:
-                type_fmt = 'identifier-function'
+                type_format = 'identifier-function'
             else:
                 j = i - 1
                 while j > 0 and tokens[j].type in (TOKENS['NEWLINE'], TOKENS['COMMENT']):
                     j -= 1
                 previous_token = tokens[j]
                 if previous_token.match(TOKENS['KEYWORD'], 'class'):
-                    type_fmt = 'identifier-type'
+                    type_format = 'identifier-type'
                 elif previous_token.match(TOKENS['KEYWORD'], 'def', 'define', 'func', 'function'):
-                    type_fmt = 'identifier-function'
+                    type_format = 'identifier-function'
                 else:
                     j = i + 1
                     if (j < len(tokens) and tokens[j].type == TOKENS['LEFT-PARENTHESIS']):
-                        type_fmt = 'identifier-function'
+                        type_format = 'identifier-function'
                     else:
-                        type_fmt = 'identifier-constant' if tvalue.isupper() else 'identifier'
+                        type_format = 'identifier-constant' if tvalue.isupper() else 'identifier'
 
         elif ttype == TOKENS['NUMBER']:
-            type_fmt = 'number'
+            type_format = 'number'
 
         elif ttype == TOKENS['STRING']:
-            type_fmt = 'string'
+            type_format = 'string'
 
         elif ttype == TOKENS['NEWLINE']:
-            type_fmt = 'newline'
+            type_format = 'newline'
 
         elif ttype == TOKENS['COMMENT']:
-            type_fmt = 'comment'
+            type_format = 'comment'
 
         elif is_bracket(ttype):
-            type_fmt = f'brackets-{len(brackets_stack) % max_bracket_level}'
+            type_format = f'brackets-{len(brackets_stack) % max_bracket_level}'
             if is_left_bracket(ttype):
                 brackets_stack.append(ttype)
             elif not (brackets_stack and BRACKETS_MAP[brackets_stack.pop()] == ttype):
-                type_fmt = 'invalid'
+                type_format = 'invalid'
             else:
-                type_fmt = f'brackets-{len(brackets_stack) % max_bracket_level}'
+                type_format = f'brackets-{len(brackets_stack) % max_bracket_level}'
 
         elif ttype == TOKENS['NONE']:
-            type_fmt = 'invalid'
+            type_format = 'invalid'
 
         else:
-            type_fmt = 'default'
+            type_format = 'default'
 
-        if space := text[last_index_position:token.position.start]:
-            result += format('default', PysPosition(file, last_index_position, token.position.start), space)
-        result += format(type_fmt, token.position, text[token.position.start:token.position.end])
+        if space := text[last_index:token.position.start]:
+            result += format('default', PysPosition(file, last_index, token.position.start), space)
+        result += format(type_format, token.position, text[token.position.start:token.position.end])
 
         if ttype == TOKENS['NULL']:
             break
 
-        last_index_position = token.position.end
+        last_index = token.position.end
 
     return result

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/interpreter.py

@@ -1,6 +1,6 @@
 from .constants import TOKENS, DEBUG
 from .cache import undefined
-from .checks import is_unpack_assignment, is_equals, is_public_attribute
+from .checks import is_list, is_equals, is_public_attribute
 from .context import PysClassContext
 from .exceptions import PysTraceback
 from .handlers import handle_call
@@ -255,17 +255,17 @@ def visit_ChainOperatorNode(node, context):
     with result(context, nposition):
 
         for i, toperand in enumerate(node.operations, start=1):
-            omatch = toperand.match
             otype = toperand.type
+            ovalue = toperand.value
             nexpression = get_expression(i)
 
             right = register(get_visitor(nexpression.__class__)(nexpression, context))
             if should_return():
                 return result
 
-            if omatch(T_KEYWORD, 'in'):
+            if otype == T_KEYWORD and ovalue == 'in':
                 value = left in right
-            elif omatch(T_KEYWORD, 'is'):
+            elif otype == T_KEYWORD and ovalue == 'is':
                 value = left is right
             elif otype == T_CE:
                 handle_call(ce, context, nposition)
@@ -313,8 +313,8 @@ def visit_BinaryOperatorNode(node, context):
 
     register = result.register
     should_return = result.should_return
-    omatch = node.operand.match
     otype = node.operand.type
+    ovalue = node.operand.value
     nleft = node.left
     nright = node.right
 
@@ -325,10 +325,10 @@ def visit_BinaryOperatorNode(node, context):
     with result(context, node.position):
         should_return_right = True
 
-        if omatch(T_KEYWORD, 'and') or otype == T_AND:
+        if (otype == T_KEYWORD and ovalue == 'and') or otype == T_AND:
             if not left:
                 return result.success(left)
-        elif omatch(T_KEYWORD, 'or') or otype == T_OR:
+        elif (otype == T_KEYWORD and ovalue == 'or') or otype == T_OR:
             if left:
                 return result.success(left)
         elif otype == T_NULLISH:
@@ -355,8 +355,8 @@ def visit_UnaryOperatorNode(node, context):
 
     register = result.register
     should_return = result.should_return
-    omatch = node.operand.match
     otype = node.operand.type
+    ovalue = node.operand.value
     nvalue = node.value
 
     value = register(get_visitor(nvalue.__class__)(nvalue, context))
@@ -364,9 +364,9 @@ def visit_UnaryOperatorNode(node, context):
         return result
 
     with result(context, node.position):
-        if omatch(T_KEYWORD, 'not') or otype == T_NOT:
+        if (otype == T_KEYWORD and ovalue == 'not') or otype == T_NOT:
             return result.success(not value)
-        elif omatch(T_KEYWORD, 'typeof'):
+        elif (otype == T_KEYWORD and ovalue == 'typeof'):
             return result.success(type(value).__name__)
         return result.success(UNARY_FUNCTIONS_MAP(otype)(value))
 
@@ -1492,7 +1492,7 @@ def visit_declaration_AssignNode(node, context, value, operand=TOKENS['EQUAL']):
         if should_return():
             return result
 
-    elif is_unpack_assignment(ntype):
+    elif is_list(ntype):
         position = node.position
 
         if not isinstance(value, Iterable):

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/objects.py

@@ -47,7 +47,7 @@ class PysFunction(PysObject):
         self.__name__ = name = '<function>' if name is None else name
         self.__qualname__ = name if qualname is None else f'{qualname}.{name}'
         self.__code__ = PysCode(
-            parameters=parameters,
+            parameters=tuple(parameters),
             body=body,
             context=context,
             position=position,
@@ -58,7 +58,7 @@ class PysFunction(PysObject):
             argument_names=tuple(argument_names),
             keyword_argument_names=tuple(keyword_argument_names),
             parameter_names=tuple(parameter_names),
-            keyword_arguments=keyword_arguments
+            combine_keyword_arguments=keyword_arguments.__or__
         )
 
     def __repr__(self):
@@ -88,7 +88,7 @@ class PysFunction(PysObject):
             set_symbol(name, arg)
             add_argument(name)
 
-        combined_keyword_arguments = code.keyword_arguments | kwargs
+        combined_keyword_arguments = code.combine_keyword_arguments(kwargs)
         pop_keyword_arguments = combined_keyword_arguments.pop
 
         for name, arg in zip(code.keyword_argument_names, args[len(registered_arguments):]):
@@ -177,11 +177,11 @@ class PysFunction(PysObject):
             )
         )
 
-        if result.should_return() and not result.func_should_return:
+        if result.should_return():
+            if result.func_should_return:
+                return result.func_return_value
             raise PysSignal(result)
 
-        return result.func_return_value
-
 class PysPythonFunction(PysFunction):
 
     def __init__(self, func):

pyscript_programming_language-1.11.2/pyscript/core/other/.nomedia

@@ -0,0 +1 @@
+don't peek!

{pyscript_programming_language-1.11.1 → pyscript_programming_language-1.11.2}/pyscript/core/parser.py

@@ -1,5 +1,5 @@
 from .bases import Pys
-from .checks import is_left_bracket, is_right_bracket
+from .checks import is_list, is_left_bracket, is_right_bracket
 from .constants import TOKENS, DEFAULT, DICT_TO_JSDICT
 from .context import PysContext
 from .exceptions import PysTraceback
@@ -1120,7 +1120,7 @@ class PysParser(Pys):
 
         while True:
 
-            if self.current_token.match(TOKENS['KEYWORD'], 'elif'):
+            if self.current_token.match(TOKENS['KEYWORD'], 'elif', 'elseif'):
                 result.register_advancement()
                 self.advance()
                 self.skip(result)
@@ -1861,13 +1861,15 @@ class PysParser(Pys):
 
         end = self.current_token.position.end
         name = self.current_token
-        bases = []
+        has_bases = False
 
         result.register_advancement()
         self.advance()
         self.skip(result)
 
         if self.current_token.type == TOKENS['LEFT-PARENTHESIS']:
+            has_bases = True
+
             base = result.register(self.sequence_expression('tuple', should_sequence=True))
             if result.error:
                 return result
@@ -1876,6 +1878,8 @@ class PysParser(Pys):
             bases = list(base.elements)
 
         elif self.current_token.match(TOKENS['KEYWORD'], 'extends'):
+            has_bases = True
+
             result.register_advancement()
             self.advance()
             self.skip(result)
@@ -1885,18 +1889,23 @@ class PysParser(Pys):
                 return result
 
             end = base.position.end
+            bases = list(base.elements) if is_list(base.__class__) else [base]
 
-            if isinstance(base, PysTupleNode):
-                if not base.elements:
-                    return result.failure(self.new_error("empty base not allowed", bases.position))
-                bases = list(base.elements)
+        else:
+            bases = []
 
-            else:
-                bases.append(base)
+        if self.current_token.type == TOKENS['COLON']:
+            return result.failure(self.new_error("unlike python"))
 
         body = result.register(self.block_statements(), True)
         if result.error:
-            return result
+            return result.failure(
+                self.new_error(
+                    "expected statement, expression, '{', or ';'"
+                    if has_bases else
+                    "expected statement, expression, 'extends', '(', '{', or ';'"
+                )
+            )
 
         return result.success(
             PysClassNode(
@@ -2138,17 +2147,9 @@ class PysParser(Pys):
         if result.error:
             return result
 
-        if isinstance(expr, PysTupleNode):
-            targets = list(expr.elements)
-            if not targets:
-                return result.failure(self.new_error("empty target not allowed", expr.position))
-
-        else:
-            targets = [expr]
-
         return result.success(
             PysDeleteNode(
-                targets,
+                list(expr.elements) if is_list(expr.__class__) else [expr],
                 position
             )
         )