pyscript-programming-language 1.15.0.dev1__py3-none-any.whl → 1.15.2__py3-none-any.whl

pyscript/__main__.py

@@ -9,10 +9,11 @@ from .core.highlight import (
     PYGMENTS, HLFMT_HTML, HLFMT_ANSI, HLFMT_BBCODE, pys_highlight, PygmentsPyScriptStyle, PygmentsPyScriptLexer
 )
 from .core.runner import _namespace_to_symbol_table, pys_runner, pys_shell
-from .core.utils.debug import USE_NOTEBOOK
+from .core.utils.debug import USE_NOTEBOOK, custom_print
 from .core.utils.generic import is_environ
 from .core.utils.module import find_module_path, remove_python_path
 from .core.utils.path import getcwd, base, normpath
+from .core.utils.string import join
 from .core.version import __version__
 
 if PYGMENTS:
@@ -41,7 +42,7 @@ if sys.version_info >= (3, 13):
         from _colorize import can_colorize
         COLORIZE = can_colorize()
     except:
-        # respect for NO_COLOR, see more here: https://no-color.org
+        # rule NO_COLOR, see more here: https://no-color.org
         COLORIZE = not is_environ('NO_COLOR')
 else:
     COLORIZE = True
@@ -138,7 +139,7 @@ parser.add_argument(
 parser.add_argument(
     '-t', '--terminal',
     action='store_true',
-    help="configure terminal encoding to UTF-8 and enable ANSI escape code processing on Windows"
+    help=f"configure terminal encoding to {pys_sys.encoding} and enable ANSI escape code processing on Windows"
 )
 
 parser.add_argument(
@@ -215,7 +216,7 @@ if args.terminal:
 
     for fd in (sys.stdout, sys.stderr, sys.stdin):
         try:
-            fd.reconfigure(encoding='utf-8')
+            fd.reconfigure(encoding=pys_sys.encoding)
         except:
             continue
 
@@ -354,10 +355,11 @@ def execute(file: PysFileBuffer) -> None:
     code, _ = result.end_process()
 
     if inspect:
-        if sys.stdout.closed or sys.stderr.closed:
+        if sys.stderr.closed:
             code = 1
-        elif sys.stdin.closed:
-            print("Can't run interactive shell: sys.stdin closed", file=sys.stderr)
+        elif sys.stdout.closed or sys.stdin.closed:
+            io_closed = join([f'sys.{std}' for std in ('stdout', 'stdin') if getattr(sys, std).closed])
+            custom_print(f"Cannot run interactive shell: {io_closed} closed", file=sys.stderr)
             code = 1
         else:
             code = pys_shell(
@@ -382,14 +384,14 @@ if args.file is not None:
     elif args.highlight:
         try:
             if args.highlight in FORMATER_HIGHLIGHT_MAP:
-                print(
+                custom_print(
                     pys_highlight(
                         source=file,
                         formatter=FORMATER_HIGHLIGHT_MAP[args.highlight]
                     )
                 )
             else:
-                print(
+                custom_print(
                     highlight(
                         code=file.text,
                         lexer=PygmentsPyScriptLexer(),

pyscript/core/constants.py

@@ -1,10 +1,11 @@
 import os
+import site
 
 PYSCRIPT_PATH = os.path.sep.join(__file__.split(os.path.sep)[:-2])
 CORE_PATH = os.path.join(PYSCRIPT_PATH, 'core')
 LIBRARIES_PATH = os.path.join(PYSCRIPT_PATH, 'lib')
 OTHER_PATH = os.path.join(PYSCRIPT_PATH, 'other')
-SITE_PACKAGES_PATH = os.path.join(PYSCRIPT_PATH, 'site-packages')
+SITE_PACKAGES_PATH = os.path.join(site.getusersitepackages(), 'pyscript')
 ICON_PATH = os.path.join(OTHER_PATH, 'PyScript.ico')
 GLOBAL_HISTORY_PATH = os.path.join(os.path.expanduser('~'), '.pyscript_history')
 CONFIGURATIONS_PATH = os.path.join(OTHER_PATH, 'configurations.json')

pyscript/core/editor/gui.py

@@ -151,11 +151,18 @@ try:
             else:
                 font_name = 'monospace'
 
-            self.lexer = PygmentsPyScriptLexer()
-            self.font = Font(family=font_name, size=boundary(self.get_configuration('gui-size-font', 10), 1, 127))
             self.line_job = None
+            self.font = Font(
+                family=font_name,
+                size=boundary(self.get_configuration('gui-size-font', 10), 1, 127)
+            )
             self.scrollbar = Scrollbar(self)
-            self.line_numbers = Canvas(self, width=0, highlightthickness=0, bd=0)
+            self.line_numbers = Canvas(
+                self,
+                width=0,
+                highlightthickness=0,
+                bd=0
+            )
             self.text = Text(
                 self,
                 undo=True,
@@ -217,7 +224,8 @@ try:
             self.wm_protocol('WM_DELETE_WINDOW', on_close)
 
             if PYGMENTS and colored:
-                self.update_job = None
+                self.lexer = PygmentsPyScriptLexer()
+                self.refresh_job = None
 
                 tag_configure = self.text.tag_configure
                 for token, style in PygmentsPyScriptStyle.list_styles():
@@ -226,7 +234,7 @@ try:
                         tag_configure(str(token), foreground=f'#{color}')
 
                 def refresh_highlight():
-                    self.update_job = None
+                    self.refresh_job = None
 
                     index = '1.0'
 
@@ -248,9 +256,9 @@ try:
 
                 def update():
                     self.title(f'PyScript {__version__} - {self.basename}{"*" if self.modified else ""}')
-                    if self.update_job is not None:
-                        self.after_cancel(self.update_job)
-                    self.update_job = self.after(500, refresh_highlight)
+                    if self.refresh_job is not None:
+                        self.after_cancel(self.refresh_job)
+                    self.refresh_job = self.after(1000, refresh_highlight)
 
             else:
                 def update():

pyscript/core/handlers.py

@@ -1,15 +1,27 @@
 from .cache import pys_sys
-from .constants import ENV_PYSCRIPT_WITH_GIL
+from .constants import SITE_PACKAGES_PATH, ENV_PYSCRIPT_WITH_GIL
 from .context import PysContext
 from .position import PysPosition
 from .pystypes import PysFunction
 from .utils.generic import is_environ
 
+from site import ENABLE_USER_SITE
 from types import MethodType
 from typing import Any
 
+import os
+
 wrapper_function = (MethodType, classmethod, staticmethod)
 
+if ENABLE_USER_SITE:
+    try:
+        if os.path.isfile(SITE_PACKAGES_PATH):
+            os.remove(SITE_PACKAGES_PATH)
+        if not os.path.exists(SITE_PACKAGES_PATH):
+            os.mkdir(SITE_PACKAGES_PATH)
+    except:
+        pass
+
 GIL = pys_sys.gil = False
 if is_environ(ENV_PYSCRIPT_WITH_GIL):
     try:

pyscript/core/highlight.py

@@ -28,7 +28,6 @@ BUILTIN_FUNCTIONS = frozenset(
 )
 
 try:
-    # if pygments module already exists
     from pygments.lexer import RegexLexer, include, bygroups
     from pygments.style import Style
     from pygments.token import (
@@ -114,7 +113,6 @@ try:
             Comment.Single: HIGHLIGHT_MAP['comment'],
             Error: HIGHLIGHT_MAP['invalid'],
             Generic.Prompt: HIGHLIGHT_MAP['keyword-other'],
-
             Punctuation.Brackets0: HIGHLIGHT_MAP['brackets-0'],
             Punctuation.Brackets1: HIGHLIGHT_MAP['brackets-1'],
             Punctuation.Brackets2: HIGHLIGHT_MAP['brackets-2']

pyscript/core/interpreter.py

@@ -308,17 +308,19 @@ def visit_BinaryOperatorNode(node: PysBinaryOperatorNode, context: PysContext) -
     result._context = context
     result._position = node.position
     with result:
-        return_right = True
 
         if otype == T_OR:
             if left:
                 return result.success(left)
+            return_right = True
         elif otype == T_AND:
             if not left:
                 return result.success(left)
+            return_right = True
         elif otype == T_NULLISH:
             if left is not None:
                 return result.success(left)
+            return_right = True
         else:
             return_right = False
 
@@ -582,11 +584,8 @@ def visit_SwitchNode(node: PysSwitchNode, context: PysContext) -> PysRunTimeResu
 
     if (fall_through or no_match_found) and (ndefault := node.default):
         register(get_visitor(ndefault.__class__)(ndefault, context))
-        if should_return():
-            if result.should_break:
-                result.should_break = False
-            else:
-                return result
+        if should_return() and not result.should_break:
+            return result
 
     return result.success(None)
 
@@ -598,13 +597,13 @@ def visit_MatchNode(node: PysMatchNode, context: PysContext) -> PysRunTimeResult
     should_return = result.should_return
     ntarget = node.target
 
-    compare = False
-
     if ntarget:
         target = register(get_visitor(ntarget.__class__)(ntarget, context))
         if should_return():
             return result
         compare = True
+    else:
+        compare = False
 
     for ncondition, nvalue in node.cases:
         condition = register(get_visitor(ncondition.__class__)(ncondition, context))
@@ -614,7 +613,7 @@ def visit_MatchNode(node: PysMatchNode, context: PysContext) -> PysRunTimeResult
         result._position = ncondition.position
         with result:
 
-            if target == condition if compare else (True if condition else False):
+            if (target == condition) if compare else condition:
                 value = register(get_visitor(nvalue.__class__)(nvalue, context))
                 if should_return():
                     return result
@@ -657,7 +656,6 @@ def visit_TryNode(node: PysTryNode, context: PysContext) -> PysRunTimeResult:
         failure(None)
 
         for (targets, tparameter), body in node.catches:
-            handle_exception = True
             stop = False
 
             if targets:
@@ -686,6 +684,9 @@ def visit_TryNode(node: PysTryNode, context: PysContext) -> PysRunTimeResult:
                         handle_exception = True
                         break
 
+            else:
+                handle_exception = True
+
             if stop:
                 break
 
@@ -902,10 +903,7 @@ def visit_ForNode(node: PysForNode, context: PysContext) -> PysRunTimeResult:
         if should_return():
             return result
 
-    if result.should_break:
-        result.should_break = False
-
-    elif nelse := node.else_:
+    if not result.should_break and (nelse := node.else_):
         register(get_visitor(nelse.__class__)(nelse, context))
         if should_return():
             return result
@@ -945,10 +943,7 @@ def visit_WhileNode(node: PysWhileNode, context: PysContext) -> PysRunTimeResult
             else:
                 return result
 
-    if result.should_break:
-        result.should_break = False
-
-    elif nelse := node.else_:
+    if not result.should_break and (nelse := node.else_):
         register(get_visitor(nelse.__class__)(nelse, context))
         if should_return():
             return result
@@ -988,10 +983,7 @@ def visit_DoWhileNode(node: PysDoWhileNode, context: PysContext) -> PysRunTimeRe
         if should_return():
             return result
 
-    if result.should_break:
-        result.should_break = False
-
-    elif nelse := node.else_:
+    if not result.should_break and (nelse := node.else_):
         register(get_visitor(nelse.__class__)(nelse, context))
         if should_return():
             return result
@@ -1033,10 +1025,7 @@ def visit_RepeatNode(node: PysRepeatNode, context: PysContext) -> PysRunTimeResu
             if should_return():
                 return result
 
-        if result.should_break:
-            result.should_break = False
-
-        elif nelse := node.else_:
+        if not result.should_break and (nelse := node.else_):
             register(get_visitor(nelse.__class__)(nelse, context))
             if should_return():
                 return result

pyscript/core/mapping.py

@@ -9,16 +9,18 @@ from operator import (
     neg, inv
 )
 
-contains     = lambda a, b : a in b
-not_contains = lambda a, b : a not in b
-and_op       = lambda a, b : a and b
-or_op        = lambda a, b : a or b
-typeof       = lambda a : type(a).__name__
+contains       = lambda a, b : a in b
+not_contains   = lambda a, b : a not in b
+and_op         = lambda a, b : a and b
+or_op          = lambda a, b : a or b
+not_isinstance = lambda a, b : not isinstance(a, b)
+typeof         = lambda a : type(a).__name__
 
 GET_BINARY_FUNCTION = {
     TOKENS['IS']: is_,
     TOKENS['IS_NOT']: is_not,
     TOKENS['INSTANCEOF']: isinstance,
+    TOKENS['NOT_INSTANCEOF']: not_isinstance,
     TOKENS['PERCENT']: mod,
     TOKENS['AMPERSAND']: and_,
     TOKENS['STAR']: mul,
@@ -150,6 +152,7 @@ SYMBOLS_TOKEN_MAP = dfrozen({
     TOKENS['IS_NOT']: 'is not',
     TOKENS['TYPEOF']: 'typeof',
     TOKENS['INSTANCEOF']: 'instanceof',
+    TOKENS['NOT_INSTANCEOF']: 'not instanceof',
     TOKENS['NEWLINE']: '\n',
     TOKENS['EXCLAMATION']: '!',
     TOKENS['COMMENT']: '#',

pyscript/core/nodes.py

@@ -274,6 +274,7 @@ class PysTernaryOperatorNode(PysNode):
         invalid: PysNode,
         style: Literal['general', 'pythonic']
     ) -> 'PysTernaryOperatorNode | PysNode':
+
         if (l_condition := _get_literal_value(condition)) is not undefined:
             return valid if l_condition else invalid
 
@@ -398,17 +399,15 @@ class PysStatementsNode(PysNode):
             return elements[0]
 
         new = []
-        constant_nodes = (PysConstantNode, PysDebugNode, PysEllipsisNode)
-        interrupt_nodes = (PysReturnNode, PysThrowNode, PysContinueNode, PysBreakNode)
 
         for node in elements:
-            if node.__class__ in constant_nodes:
+            if node.__class__ in _constant_nodes:
                 continue
             elif node.__class__ is PysStatementsNode:
                 new.extend(node.elements)
             else:
                 new.append(node)
-            if node.__class__ in interrupt_nodes:
+            if node.__class__ in _interrupt_nodes:
                 break
 
         self = super().__new__(cls, position)
@@ -478,9 +477,9 @@ class PysIfNode(PysNode):
         if not new_cases:
             return else_ if else_ else PysStatementsNode(position, [])
 
-        elif len(new_cases) == 1:
+        elif not else_ and len(new_cases) == 1:
             condition, body = new_cases[0]
-            if body.__class__ is PysIfNode and len(body.cases) == 1 and body.else_:
+            if body.__class__ is PysIfNode and len(body.cases) == 1 and not body.else_:
                 inner_condition, inner_body = body.cases[0]
                 new_cases = [(
                     PysBinaryOperatorNode(
@@ -510,12 +509,16 @@ class PysSwitchNode(PysNode):
         target: PysNode,
         cases: list[tuple[PysNode, PysNode]],
         default: PysNode | None
-    ) -> 'PysSwitchNode':
+    ) -> 'PysSwitchNode | PysNode':
+        default = _optional_part(default)
+
+        if not (cases or default):
+            return target
 
         self = super().__new__(cls, position)
         setimuattr(self, 'target', target)
         setimuattr(self, 'cases', tuple(cases))
-        setimuattr(self, 'default', _optional_part(default))
+        setimuattr(self, 'default', default)
         return self
 
     def __repr__(self) -> str:
@@ -532,12 +535,31 @@ class PysMatchNode(PysNode):
         target: PysNode | None,
         cases: list[tuple[PysNode, PysNode]],
         default: PysNode | None
-    ) -> 'PysMatchNode':
+    ) -> 'PysMatchNode | PysNode':
+
+        if target and (l_target := _get_literal_value(target)) is not undefined:
+            new_cases = []
+
+            for condition, value in cases:
+                if (l_condition := _get_literal_value(condition)) is undefined:
+                    new_cases.append((condition, value))
+                elif l_target == l_condition:
+                    default = value
+                    break
+
+            cases = new_cases
+            default = _optional_part(default, expression=True)
+
+            if not cases:
+                return default if default else PysConstantNode(position, None)
+
+        else:
+            default = _optional_part(default, expression=True)
 
         self = super().__new__(cls, position)
         setimuattr(self, 'target', target)
         setimuattr(self, 'cases', tuple(cases))
-        setimuattr(self, 'default', _optional_part(default))
+        setimuattr(self, 'default', default)
         return self
 
     def __repr__(self) -> str:
@@ -602,8 +624,7 @@ class PysForNode(PysNode):
     def __new__(
         cls,
         position: PysPosition,
-        header: tuple[PysNode | None, PysNode | None, PysNode | None] |
-                tuple[PysNode, PysNode],
+        header: tuple[PysNode | None, PysNode | None, PysNode | None] | tuple[PysNode, PysNode],
         body: PysNode,
         else_: PysNode | None
     ) -> 'PysForNode':
@@ -628,12 +649,16 @@ class PysWhileNode(PysNode):
         condition: PysNode,
         body: PysNode,
         else_: PysNode | None
-    ) -> 'PysWhileNode':
+    ) -> 'PysWhileNode | PysNode':
+        else_ = _optional_part(else_)
+
+        if (l_condition := _get_literal_value(condition)) is not undefined and not l_condition:
+            return else_ if else_ else PysStatementsNode(position, [])
 
         self = super().__new__(cls, position)
         setimuattr(self, 'condition', condition)
         setimuattr(self, 'body', body)
-        setimuattr(self, 'else_', _optional_part(else_))
+        setimuattr(self, 'else_', else_)
         return self
 
     def __repr__(self) -> str:
@@ -747,8 +772,17 @@ class PysGlobalNode(PysNode):
 
     @typecheck
     def __new__(cls, position: PysPosition, identifiers: list[PysToken]) -> 'PysGlobalNode':
+        registered = set()
+        new = []
+
+        for identifier in identifiers:
+            if identifier.value in registered:
+                continue
+            registered.add(identifier.value)
+            new.append(identifier)
+
         self = super().__new__(cls, position)
-        setimuattr(self, 'identifiers', tuple(set(identifiers)))
+        setimuattr(self, 'identifiers', tuple(new))
         return self
 
     def __repr__(self) -> str:
@@ -761,7 +795,7 @@ class PysReturnNode(PysNode):
     @typecheck
     def __new__(cls, position: PysPosition, value: PysNode | None) -> 'PysReturnNode':
         self = super().__new__(cls, position)
-        setimuattr(self, 'value', _optional_part(value))
+        setimuattr(self, 'value', _optional_part(value, expression=True))
         return self
 
     def __repr__(self) -> str:
@@ -846,6 +880,9 @@ class PysBreakNode(PysNode):
     def __repr__(self) -> Literal['Break()']:
         return 'Break()'
 
+_constant_nodes = frozenset([PysConstantNode, PysDebugNode, PysEllipsisNode])
+_interrupt_nodes = frozenset([PysReturnNode, PysThrowNode, PysContinueNode, PysBreakNode])
+
 def _get_literal_value(item: Any) -> Any | PysUndefined:
 
     if isinstance(item, (PysConstantNode, PysToken)):
@@ -877,9 +914,9 @@ def _get_literal_value(item: Any) -> Any | PysUndefined:
 
     return undefined
 
-def _optional_part(part: PysNode | None) -> PysNode | None:
+def _optional_part(part: PysNode | None, *, expression: bool = False) -> PysNode | None:
     return None if (
+        (not expression and part.__class__ in _constant_nodes) or
         _get_literal_value(part) is None or
-        (part.__class__ is PysStatementsNode and not part.elements) or
-        (part.__class__ in (PysDebugNode, PysEllipsisNode))
+        (part.__class__ is PysStatementsNode and not part.elements)
     ) else part