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

pyscript/core/parser.py

@@ -401,7 +401,22 @@ class PysParser(Pys):
         )
 
     def instanceof(self) -> PysParserResult:
-        return self.binary_operator(self.bitwise, (TOKENS['KEYWORD'], 'instanceof'), instanceof=True)
+        result = PysParserResult()
+
+        node = result.try_register(self.binary_operator(
+            self.bitwise,
+            (TOKENS['KEYWORD'], 'instanceof'),
+            (TOKENS['KEYWORD'], 'not'),
+            instanceof=True
+        ))
+
+        if result.error:
+            return result
+        elif node:
+            return result.success(node)
+
+        self.reverse(result.to_reverse_count)
+        return self.bitwise()
 
     def bitwise(self) -> PysParserResult:
         return self.binary_operator(
@@ -1182,66 +1197,71 @@ class PysParser(Pys):
 
         self.skip(result)
 
-        if self.current_token.type != TOKENS['LEFT_CURLY']:
-            return result.failure(self.new_error("expected '{'"))
+        cases = []
+        default = None
 
-        left_bracket_token = self.current_token
+        if self.current_token.type == TOKENS['SEMICOLON']:
+            result.register_advancement()
+            self.advance()
 
-        result.register_advancement()
-        self.advance()
-        self.skip(result)
+        elif self.current_token.type == TOKENS['LEFT_CURLY']:
+            left_bracket_token = self.current_token
 
-        cases = []
-        default = None
+            result.register_advancement()
+            self.advance()
+            self.skip(result)
 
-        while True:
+            while True:
 
-            if self.current_token.match(TOKENS['KEYWORD'], 'case'):
-                result.register_advancement()
-                self.advance()
-                self.skip(result)
+                if self.current_token.match(TOKENS['KEYWORD'], 'case'):
+                    result.register_advancement()
+                    self.advance()
+                    self.skip(result)
 
-                case = result.register(self.walrus(), True)
-                if result.error:
-                    return result
+                    case = result.register(self.walrus(), True)
+                    if result.error:
+                        return result
 
-                self.skip(result)
+                    self.skip(result)
 
-                if self.current_token.type != TOKENS['COLON']:
-                    return result.failure(self.new_error("expected ':'"))
+                    if self.current_token.type != TOKENS['COLON']:
+                        return result.failure(self.new_error("expected ':'"))
 
-                result.register_advancement()
-                self.advance()
+                    result.register_advancement()
+                    self.advance()
 
-                body = result.register(self.statements())
-                if result.error:
-                    return result
+                    body = result.register(self.statements())
+                    if result.error:
+                        return result
 
-                cases.append((case, body))
+                    cases.append((case, body))
 
-            elif self.current_token.match(TOKENS['KEYWORD'], 'default', 'else'):
-                result.register_advancement()
-                self.advance()
-                self.skip(result)
+                elif self.current_token.match(TOKENS['KEYWORD'], 'default', 'else'):
+                    result.register_advancement()
+                    self.advance()
+                    self.skip(result)
 
-                if self.current_token.type != TOKENS['COLON']:
-                    return result.failure(self.new_error("expected ':'"))
+                    if self.current_token.type != TOKENS['COLON']:
+                        return result.failure(self.new_error("expected ':'"))
 
-                result.register_advancement()
-                self.advance()
+                    result.register_advancement()
+                    self.advance()
 
-                default = result.register(self.statements())
-                if result.error:
-                    return result
+                    default = result.register(self.statements())
+                    if result.error:
+                        return result
 
-                break
+                    break
 
-            else:
-                break
+                else:
+                    break
 
-        self.close_bracket(result, left_bracket_token)
-        if result.error:
-            return result
+            self.close_bracket(result, left_bracket_token)
+            if result.error:
+                return result
+
+        else:
+            return result.failure(self.new_error("expected '{'"))
 
         return result.success(
             PysSwitchNode(
@@ -2325,15 +2345,12 @@ class PysParser(Pys):
             if result.error:
                 return result
 
-            if body.__class__ == PysStatementsNode:
-                setimuattr(
-                    body, 'position',
-                    PysPosition(
-                        self.current_token.position.file,
-                        left_bracket_token.position.start,
-                        end
-                    )
-                )
+            if body.__class__ is PysStatementsNode:
+                setimuattr(body, 'position', PysPosition(
+                    self.current_token.position.file,
+                    left_bracket_token.position.start,
+                    end
+                ))
 
             return result.success(body)
 
@@ -2350,10 +2367,7 @@ class PysParser(Pys):
 
         body = result.register(self.statement())
         if result.error:
-            return result.failure(
-                self.new_error("expected statement, expression, '{', or ';'"),
-                fatal=False
-            )
+            return result.failure(self.new_error("expected statement, expression, '{', or ';'"), fatal=False)
 
         return result.success(body)
 
@@ -2393,7 +2407,7 @@ class PysParser(Pys):
                 self.skip_expression(result)
 
                 if not self.current_token.match(TOKENS['KEYWORD'], 'in'):
-                    return result.failure(self.new_error("expected 'in'"))
+                    return result.failure(self.new_error("expected 'in' or 'instanceof'"))
 
                 operations[-1] = PysToken(
                     TOKENS['EXCLAMATION_GREATER_THAN'],
@@ -2483,11 +2497,28 @@ class PysParser(Pys):
                     TOKENS['DOUBLE_AMPERSAND' if token.value == 'and' else 'DOUBLE_PIPE'],
                     token.position
                 )
+
             elif instanceof:
-                operand = PysToken(
-                    TOKENS['INSTANCEOF'],
-                    token.position
-                )
+
+                if token.match(TOKENS['KEYWORD'], 'not'):
+                    result.register_advancement()
+                    self.advance()
+                    self.skip_expression(result)
+
+                    if not self.current_token.match(TOKENS['KEYWORD'], 'instanceof'):
+                        return result.failure(self.new_error("expected 'instanceof'"), fatal=False)
+
+                    operand = PysToken(
+                        TOKENS['NOT_INSTANCEOF'],
+                        token.position
+                    )
+
+                else:
+                    operand = PysToken(
+                        TOKENS['INSTANCEOF'],
+                        token.position
+                    )
+
             else:
                 operand = token
 

pyscript/core/pysbuiltins.py

@@ -37,6 +37,7 @@ static_wrapper_function = (staticmethod,)
 wrapper_function = (MethodType, PysPythonFunction, classmethod)
 python_function = (BuiltinFunctionType, BuiltinMethodType, FunctionType)
 
+pynewobject = object.__new__
 pyvars = builtins.vars
 pydir = builtins.dir
 
@@ -55,34 +56,36 @@ def _magic_method(
     return NotImplemented
 
 def _unpack_comprehension_function(context: PysContext, position: PysPosition, function: Callable) -> Callable:
-    check = function
-    final = function
-    offset = 0
+    check = final = function
+    length = offset = 0
 
-    if isinstance(function, wrapper_function):
+    b_isinstance = isinstance
+
+    if b_isinstance(function, wrapper_function):
         check = function.__func__
-        offset += 2 if isinstance(function, PysPythonFunction) else 1
-    elif isinstance(function, static_wrapper_function):
+        offset += 2 if b_isinstance(function, PysPythonFunction) else 1
+    elif b_isinstance(function, static_wrapper_function):
         check = function.__func__
+    elif b_isinstance(function, type):
+        offset += 1
+        check = function.__new__
+        if check is pynewobject:
+            check = function.__init__
 
-    if isinstance(check, PysFunction):
+    if b_isinstance(check, PysFunction):
         length = max(check.__code__.parameters_length - offset, 0)
-        if length == 0:
-            def final(item):
-                return function()
-        elif length > 1:
-            def final(item):
-                return function(*item)
-
-    elif isinstance(check, python_function):
+    elif b_isinstance(check, python_function):
         parameters = signature(check).parameters
         length = max(len(parameters) - offset, 0)
-        if length == 0:
-            def final(item):
-                return function()
-        elif length > 1 or any(p.kind == p.VAR_POSITIONAL for p in parameters.values()):
-            def final(item):
-                return function(*item)
+        if length == 1 and any(p.kind == p.VAR_POSITIONAL for p in parameters.values()):
+            length = 2
+
+    if length == 0:
+        def final(item):
+            return function()
+    elif length > 1:
+        def final(item):
+            return function(*item)
 
     handle_call(function, context, position)
     return final
@@ -116,8 +119,7 @@ def require(context, position, name):
     name: A name or path of the module to be imported.
     """
 
-    name, *other_components = normstr(name).split('>')
-
+    name, *components = normstr(name).split('>')
     filename = context.file.name
     path, module_path = find_module_path(filename, name)
 
@@ -189,9 +191,8 @@ def require(context, position, name):
             finally:
                 loading_modules.discard(module_path)
 
-    for component in other_components:
+    for component in components:
         module = getattr(module, component)
-
     return module
 
 @PysBuiltinFunction
@@ -386,7 +387,7 @@ def dir(context, position, *args):
 def exec(context, position, source, globals=None):
 
     """
-    exec(source: str | bytes, globals: Optional[dict]) -> None
+    exec(source: str | bytes | bytearray | Iterable | IOBase, globals: Optional[dict] = None) -> None
 
     Executes PyScript code statements from the given source.
 
@@ -416,7 +417,7 @@ def exec(context, position, source, globals=None):
 def eval(context, position, source, globals=None):
 
     """
-    eval(source: str | bytes, globals: Optional[dict]) -> None
+    eval(source: str | bytes | bytearray | Iterable | IOBase, globals: Optional[dict] = None) -> None
 
     Executes a PyScript code expression from the given source.
 
@@ -460,7 +461,8 @@ def ce(context, position, a, b, *, rel_tol=1e-9, abs_tol=0):
     abs_tol: maximum difference for being considered "close", regardless of the magnitude of the input values.
     """
 
-    if isinstance(a, real_complex_number) and isinstance(b, real_complex_number):
+    b_isinstance = isinstance
+    if b_isinstance(a, real_complex_number) and b_isinstance(b, real_complex_number):
         return isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol)
 
     result = _magic_method(context, position, a, '__ce__', b, rel_tol=rel_tol, abs_tol=abs_tol)
@@ -494,7 +496,8 @@ def nce(context, position, a, b, *, rel_tol=1e-9, abs_tol=0):
     abs_tol: maximum difference for being considered "close", regardless of the magnitude of the input values.
     """
 
-    if isinstance(a, real_complex_number) and isinstance(b, real_complex_number):
+    b_isinstance = isinstance
+    if b_isinstance(a, real_complex_number) and b_isinstance(b, real_complex_number):
         return not isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol)
 
     result = _magic_method(context, position, a, '__nce__', b, rel_tol=rel_tol, abs_tol=abs_tol)
@@ -525,9 +528,10 @@ def increment(context, position, object):
     __increment__ method, which if unsuccessful will throw a TypeError.
     """
 
-    if isinstance(object, real_number):
+    b_isinstance = isinstance
+    if b_isinstance(object, real_number):
         return object + 1
-    elif isinstance(object, sequence):
+    elif b_isinstance(object, sequence):
         return tuple(_pyincrement(context, position, obj) for obj in object)
 
     result = _magic_method(context, position, object, '__increment__')
@@ -549,9 +553,10 @@ def decrement(context, position, object):
     call the __decrement__ method, which if unsuccessful will throw a TypeError.
     """
 
-    if isinstance(object, real_number):
+    b_isinstance = isinstance
+    if b_isinstance(object, real_number):
         return object - 1
-    elif isinstance(object, sequence):
+    elif b_isinstance(object, sequence):
         return tuple(_pydecrement(context, position, obj) for obj in object)
 
     result = _magic_method(context, position, object, '__decrement__')

pyscript/core/pystypes.py

@@ -11,7 +11,6 @@ from .utils.generic import setimuattr, dinit, drepr, dor, dror, dior, dsetitem,
 from .utils.similarity import diff_get_closest
 from .utils.string import join
 
-from builtins import help as pyhelp
 from itertools import islice
 from types import MethodType
 from typing import Any, Callable, Optional
@@ -203,7 +202,7 @@ class PysFunction(PysObject):
                     PysTraceback(
                         TypeError(
                             f"{self.__qualname__}() missing {total_missing} required positional argument"
-                            f"{'' if total_missing == 1 else 's'}: {join(missing_arguments, conjunction='and')}"
+                            f"{'' if total_missing == 1 else 's'}: {join(missing_arguments)}"
                         ),
                         context,
                         position
@@ -311,10 +310,16 @@ class PysPrinter(PysObject):
 
 class PysHelper(PysPrinter):
 
-    __slots__ = ()
+    __slots__ = ('_pyhelp',)
 
     def __init__(self) -> None:
         super().__init__('help')
+        try:
+            from builtins import help
+        except:
+            def help(*args, **kwargs):
+                raise NotImplementedError('python builtins.help not found')
+        setimuattr(self, '_pyhelp', help)
 
     def __repr__(self) -> str:
         return f'Type {self.name}() for interactive help, or {self.name}(object) for help about object.'
@@ -328,4 +333,4 @@ class PysHelper(PysPrinter):
                 "To get the list of builtin functions, types, exceptions, and other objects, type 'help(\"builtins\")'."
             )
         else:
-            pyhelp(*args, **kwargs)
+            self._pyhelp(*args, **kwargs)

pyscript/core/runner.py

@@ -153,13 +153,14 @@ def pys_runner(
         pys_sys.flags = context.flags
 
         try:
-            del file, flags, symbol_table, context_parent, context_parent_entry_position, \
-                lexer, tokens, error, parser, analyzer
+            del (
+                file, flags, symbol_table, context_parent, context_parent_entry_position, lexer, tokens, error, parser,
+                analyzer
+            )
         except:
             pass
 
         visitor_result = get_visitor(node.__class__)(node, context)
-
         if visitor_result.error:
             return result.failure(visitor_result.error)
 

pyscript/core/shell.py

@@ -233,10 +233,8 @@ try:
     @singleton
     class PysHistory(Pys, History):
 
-        def __new_singleton__(cls) -> 'PysHistory':
-            if USE_FILE_HISTORY:
-                return super().__new__(cls)
-            raise NotImplementedError('not using file history')
+        def __new_singleton__(cls) -> 'PysHistory | InMemoryHistory':
+            return super().__new__(cls) if USE_FILE_HISTORY else InMemoryHistory()
 
         def _write_history_safely(self, mode: str, function: str, *args) -> None:
             try:
@@ -254,16 +252,16 @@ try:
                 self._write_history_safely('w', 'write', '')
                 return []
 
-            try:
-                strings = []
-                lines = []
+            strings = []
+            lines = []
 
-                def add_to_string():
-                    if not lines:
-                        return
-                    strings.insert(0, '\n'.join(lines))
-                    lines.clear()
+            def add_to_string():
+                if not lines:
+                    return
+                strings.insert(0, '\n'.join(lines))
+                lines.clear()
 
+            try:
                 with open(HISTORY_PATH, 'r', encoding=pys_sys.encoding) as file:
                     for line in file:
                         line = line[:-1]
@@ -273,13 +271,15 @@ try:
                         lines.append(line)
                     add_to_string()
 
-                if HISTORY_LIMIT > 0 and len(strings) > HISTORY_LIMIT:
+                if 0 < HISTORY_LIMIT < len(strings):
                     self._manage_history_capacity(strings)
 
-                return strings
             except:
                 return []
 
+            else:
+                return strings
+
         # this function is called within `append_string()` which adds a new string or history entry to `_loaded_strings`
         # before invoking this function
         def store_string(self, string: str) -> None:
@@ -290,8 +290,6 @@ try:
             else:
                 self._manage_history_capacity(self._loaded_strings)
 
-    history = (PysHistory if USE_FILE_HISTORY else InMemoryHistory)()
-
     class PysPromptToolkitLineShell(PysLineShell, PromptSession):
 
         def __init__(self, ps1: str = '>>> ', ps2: str = '... ', colored: bool = True) -> None:
@@ -381,7 +379,7 @@ try:
                 input_processors=[TabsProcessor(tabstop=4)],
                 key_bindings=key_bindings,
                 prompt_continuation=lambda width, line_number, is_soft_wrap: self._ps2,
-                history=history,
+                history=PysHistory(),
                 **other_keyword
             )
 

pyscript/core/token.py

@@ -25,6 +25,7 @@ TOKENS = dfrozen({
     'TYPEOF': 0x08,
     'INSTANCEOF': 0x09,
     'NEWLINE': ord('\n'),
+    'NOT_INSTANCEOF': 0x0b,
     'EXCLAMATION': ord('!'),
     'COMMENT': ord('#'),
     'PERCENT': ord('%'),

pyscript/core/utils/debug.py

@@ -40,13 +40,13 @@ def import_readline() -> Literal[False]:
 USE_NOTEBOOK = False
 
 try:
-    from IPython import get_ipython
+    from IPython import get_ipython  # type: ignore
     if type(get_ipython()).__name__ in (
         'ZMQInteractiveShell',     # Jupyter Notebook / Lab
         'Shell',                   # Google Colab
         'TerminalInteractiveShell' # IPython Terminal
     ):
-        from IPython.display import clear_output
+        from IPython.display import clear_output  # type: ignore
         def clear_shell() -> None:
             clear_output()
         USE_NOTEBOOK = True

pyscript/core/utils/decorators.py

@@ -13,9 +13,10 @@ class _PysUtilities(Pys):
         # circular import problem solved
         from ..cache import pys_sys
         singletons = pys_sys.singletons
-        if type(singletons.get(cls, None)) is not cls:
-            singletons[cls] = cls.__new_singleton__(cls, *args, **kwargs)
-        return singletons[cls]
+        object = singletons.get(cls, None)
+        if type(object) is not cls:
+            singletons[cls] = object = cls.__new_singleton__(cls, *args, **kwargs)
+        return object
 
     @staticmethod
     def readonly_attribute(*args, **kwargs):
@@ -34,10 +35,11 @@ def typecheck(func, *args, **kwargs):
 if not is_environ(ENV_PYSCRIPT_NO_TYPECHECK):
     try:
         from beartype import beartype as typecheck
-        TYPECHECK_STACK += 1
-        BEARTYPE = True
     except:
         pass
+    else:
+        TYPECHECK_STACK += 1
+        BEARTYPE = True
 
 def immutable(cls):
     cls.__setattr__ = _PysUtilities.readonly_attribute

pyscript/core/utils/generic.py

@@ -1,5 +1,5 @@
 from inspect import currentframe
-from types import FrameType, MappingProxyType, UnionType
+from types import FrameType, UnionType
 from typing import Any, Optional, Sequence
 
 import os
@@ -21,10 +21,11 @@ dclear = dict.clear
 dget = dict.get
 dkeys = dict.keys
 ditems = dict.items
-dfrozen = MappingProxyType
 
 if sys.version_info >= (3, 15):
     dfrozen = frozendict
+else:
+    from types import MappingProxyType as dfrozen
 
 def get_frame(deep: int = 0) -> FrameType | None:
     deep += 1

pyscript/core/utils/module.py

@@ -22,6 +22,9 @@ def get_module_candidate(path: str, entry: str = '__init__') -> str | None:
         return candidate
 
 def find_module_path(filename: str | None, name: str, entry: str = '__init__') -> tuple[str | None, str | None]:
+    if name in ('_pyscript', 'builtins', 'sys'):
+        return None, None
+
     # circular import problem solved
     from ..cache import pys_sys
 

pyscript/core/utils/string.py

@@ -38,11 +38,15 @@ def normstr(obj) -> str:
 
 def join(sequence: Sequence[str], conjunction: str = 'and') -> str:
     length = len(sequence)
-    if length == 1:
+    if length == 0:
+        return ''
+    elif length == 1:
         return sequence[0]
     elif length == 2:
-        return f'{sequence[0]} {conjunction} {sequence[1]}'
-    return f'{", ".join(sequence[:-1])}, {conjunction} {sequence[-1]}'
+        a, b = sequence
+        return f'{a} {conjunction} {b}'
+    *others, end = sequence
+    return f'{", ".join(others)}, {conjunction} {end}'
 
 def indent(string: str, length: int, indent: str = ' ') -> str:
     prefix = indent * length

pyscript/core/version.py

@@ -4,9 +4,11 @@ from .mapping import TAG_VERSION_MAP
 from .utils.decorators import immutable, inheritable, singleton
 
 from re import match as match_regex
+from types import NotImplementedType
+from typing import Any
 
-__version__ = '1.15.0.dev1'
-__date__ = '19 October 2026, 11:45 UTC+7'
+__version__ = '1.15.2'
+__date__ = '08 November 2026, 12:30 UTC+7'
 __author__ = ('AzzamMuhyala',)
 
 version = pys_sys.version = f'{__version__} ({__date__})'
@@ -72,6 +74,15 @@ class PysVersionInfo(Pys, tuple):
     def release(self) -> tuple[int, int, int]:
         return self[0:3]
 
+    def __add__(self, other: Any) -> NotImplementedType:
+        return NotImplemented
+
+    def __mul__(self, other: Any) -> NotImplementedType:
+        return NotImplemented
+
+    def __rmul__(self, other: Any) -> NotImplementedType:
+        return NotImplemented
+
     def __lt__(self, other: tuple) -> bool:
         return self.release < other